AIPlatform/aipsvr/Services/AdminService.cs

using AIPlatform.Protocol.Entities;
using AIPlatform.Protocol.Entities.Ventilator;
using AIPlatform.Protocol.Model;
using AIPlatform.Protocol.Services;
using AIPlatform.Protocol.Utilities;
using aipsvr.Managers;
using aipsvr.Services.DatabaseManagers;
using aipsvr.Utilities;
using Newtonsoft.Json;
using SixLabors.ImageSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using VideoFrameSimilarityUtilsLib;
using WingInterfaceLibrary.DTO.Device;
using WingInterfaceLibrary.Request.IOTDevice;

namespace aipsvr.Services
{
    class AdminService : IService, IAdminService
    {
        private void ActivateSession(long sessionId)
        {
            SessionManager.ActivateSession(sessionId);
        }

        public AdminService()
        {
            FileUtils.CreateDirectory(CommonConfigManager.VideoBatchSizeFolder);
            FileUtils.CreateDirectory(CommonConfigManager.VideoTranscodingFolder);
        }

        public void Initialize()
        {

        }

        /// <summary>
        /// Login the system with admin name and password.
        /// </summary>
        /// <param name="name">The name of the admin</param>
        /// <param name="password">The password of the admin</param>
        /// <returns>The login result</returns>
        public async Task<AdminLoginResult> LoginAsync(string name, string password)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var accountDataManager = databaseService.GetManager<IAccountDataManager>();
            var account = await accountDataManager.GetAccountAsync(name);
            if (account != null)
            {
                var md5Password = password.ToMd5();
                if (account.Password == md5Password)
                {
                    if (account.IsRoot || account.Roles.Contains(Role.WebAdministrator))
                    {
                        //var authorityMenuDataManager = databaseService.GetManager<IAuthorityMenuDataManager>();
                        //var authorities = await authorityMenuDataManager.GetAuthorityMenusAsync();
                        var session = new AdminAccountSession
                        {
                            Id = IdCreator.CreateId(),
                            AccountId = account.Id,
                            Name = account.Name,
                            FullName = account.FullName,
                            Type = SessionType.Admin,
                            IsRoot = account.IsRoot,
                            Organizations = account.Organizations,
                            Roles = account.Roles,
                            Authorities = account.AdminAuthorities,
                            SupportedDataTypes = account.SupportedDataTypes,
                            EncryptedPassword = md5Password,
                            InstitutionId = account.InstitutionId,
                        };
                        SessionManager.AddSession(session);
                        await SystemLogger.WriteLogAsync($"Admin - {name} logon system.");
                        var successResult = new AdminLoginResult { ResultCode = LoginResultCode.Success, Session = session };
                        return successResult;
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {name} has no permission.");
                    var noPermissionResult = new AdminLoginResult { ResultCode = LoginResultCode.NoPermission, Session = null };
                    return noPermissionResult;
                }
                await SystemLogger.WriteLogAsync($"Admin - {name} input wrong password.");
                var wrongPasswordResult = new AdminLoginResult { ResultCode = LoginResultCode.WrongPassword, Session = null };
                return wrongPasswordResult;
            }
            await SystemLogger.WriteLogAsync($"Admin - {name} does not exist.");
            var notExitsResult = new AdminLoginResult { ResultCode = LoginResultCode.NotExist, Session = null };
            return notExitsResult;
        }

        /// <summary>
        /// SeniorLabeler login to the system to check the labeler statistics
        /// </summary>
        /// <param name="name">The name of the senior labeler</param>
        /// <param name="password">The password of the senior labeler</param>
        /// <returns>The login result.</returns>
        public async Task<LabelerLoginResult> SeniorLabelerLoginAsync(string name, string password)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var accountDataManager = databaseService.GetManager<IAccountDataManager>();
            var account = await accountDataManager.GetAccountAsync(name);
            if (account != null)
            {
                var md5Password = password.ToMd5();
                if (account.Password == md5Password)
                {
                    if (account.IsRoot || account.Roles.Contains(Role.Labeler))
                    {
                        var session = new LabelerAccountSession
                        {
                            Id = IdCreator.CreateId(),
                            AccountId = account.Id,
                            Name = account.Name,
                            FullName = account.FullName,
                            Type = SessionType.Admin,
                            Organizations = account.Organizations,
                        };
                        SessionManager.AddSession(session);
                        await SystemLogger.WriteLogAsync($"SeniorLabeler - {name} logon system.");
                        var successResult = new LabelerLoginResult { ResultCode = LoginResultCode.Success, Session = session };
                        return successResult;
                    }
                    await SystemLogger.WriteLogAsync($"SeniorLabeler - {name} has no permission.");
                    var noPermissionResult = new LabelerLoginResult { ResultCode = LoginResultCode.NoPermission, Session = null };
                    return noPermissionResult;
                }
                await SystemLogger.WriteLogAsync($"SeniorLabeler - {name} input wrong password.");
                var wrongPasswordResult = new LabelerLoginResult { ResultCode = LoginResultCode.WrongPassword, Session = null };
                return wrongPasswordResult;
            }
            await SystemLogger.WriteLogAsync($"SeniorLabeler - {name} does not exist.");
            var notExitsResult = new LabelerLoginResult { ResultCode = LoginResultCode.NotExist, Session = null };
            return notExitsResult;
        }

        /// <summary>
        /// Logoff from system.
        /// </summary>
        /// <param name="sessionId">The session id.</param>
        /// <returns></returns>
        public async Task LogOff(long sessionId)
        {
            await Task.Run(() =>
            {
                SessionManager.RemoveSessionBySessionId(sessionId);
            });
        }

        #region organization management

        /// <summary>
        /// Get all organizations from system
        /// </summary>
        /// <param name="sessionId">The session of current admin</param>
        /// <returns>The loaded organizations.</returns>
        public async Task<List<Organization>> GetOrganizationsAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var ids = session.Organizations.Select(x => x.Id).ToList();
                    return await organizationDataManager.GetOrganizationsAsync(session.IsRoot, ids);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all organizations from system
        /// </summary>
        /// <param name="pageIndex">The index of page.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <param name="keyword">The searched key word.</param>
        /// <returns>The loaded organizations.</returns>
        public async Task<List<Organization>> GetOrganizationsAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var ids = session.Organizations.Select(x => x.Id).ToList();
                    return await organizationDataManager.GetOrganizationsAsync(pageIndex, pageSize, keyword, session.IsRoot, ids);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get total organization count.
        /// </summary>
        /// <param name="keyword">The searched key word.</param>
        /// <returns>The organization count.</returns>
        public async Task<int> GetOrganizationCountAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var ids = session.Organizations.Select(x => x.Id).ToList();
                    return (int)await organizationDataManager.GetOrganizationCountAsync(keyword, session.IsRoot, ids);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Create an organization
        /// </summary>
        /// <param name="name">The name of the organization.</param>
        /// <param name="description">The description of the organization.</param>
        /// <returns></returns>
        public async Task<Organization> CreateOrganizationAsync(long sessionId, string name, string description, List<AuthorityBase> authorities, List<SupportedDataType> supportedDataTypes)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var organization = await organizationDataManager.GetOrganizationAsync(name);
                    if (organization == null)
                    {
                        organization = new Organization
                        {
                            Name = name,
                            Description = description,
                            Authorities = authorities,
                            SupportedDataTypes = supportedDataTypes,
                            Creator = new EntityBase { Id = session.AccountId, Name = session.Name }
                        };
                        await organizationDataManager.CreateOrganizationAsync(organization);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} created organization {organization.Name}");
                        return organization;
                    }

                    throw new InvalidOperationException("OrganizationAlreadyExists");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete an organization from the system.
        /// </summary>
        /// <returns>Void</returns>
        public async Task DeleteOrganizationAsync(long sessionId, long id)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var organization = await organizationDataManager.GetOrganizationAsync(id);
                    if (organization != null)
                    {
                        await organizationDataManager.DeleteOrganizationAsync(id);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted organization {organization.Name}");
                        return;
                    }
                    throw new InvalidOperationException("OrganizationNotExist");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Check whether there are children in the organization.
        /// </summary>
        /// <param name="id">The id of organization.</param>
        /// <returns>The loaded organizations.</returns>
        public async Task<bool> ExistOrganizationChildrenAsync(long sessionId, long id)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var categories = await imageCategoryDataManager.GetImageCategoriesByOrganizationIdAsync(id);
                    var isExist = categories != null && categories.Count > 0;
                    return isExist;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Check whether there are children in the organization.
        /// </summary>
        /// <param name="organization">The organization.</param>
        /// <returns>The loaded organizations.</returns>
        public async Task<bool> ExistAccountByOrganizationAsync(long sessionId, EntityBase organization)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var orgs = new List<EntityBase> { organization };
                    var count = await accountDataManager.GetAccountCountAsync(null, session.IsRoot, orgs);
                    return count > 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update one organization.
        /// </summary>
        /// <param name="id">The id of organization.</param>
        /// <param name="description">The description of the organization.</param>
        /// <returns>Void</returns>
        public async Task UpdateOrganizationAsync(long sessionId, long id, string description, List<AuthorityBase> authorities, List<SupportedDataType> supportedDataTypes)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var organization = await organizationDataManager.GetOrganizationAsync(id);
                    if (organization != null)
                    {
                        organization.Description = description;
                        organization.Authorities = authorities;
                        organization.SupportedDataTypes = supportedDataTypes;
                        await organizationDataManager.UpdateOrganizationAsync(organization);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} updated organization {organization.Name}");
                    }
                    else
                    {
                        throw new InvalidOperationException("OrganizationNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        #endregion organization management

        /// <summary>
        /// Get all system admins.
        /// </summary>
        /// <param name="sessionId">The session of current admin</param>
        /// <returns>The loaded admins</returns>
        public async Task<List<Account>> GetAccountsAsync(long sessionId, Role role)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    return await accountDataManager.GetAccountsAsync();
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all admins from system
        /// </summary>
        /// <param name="sessionId">The session of current admin</param>
        /// <param name="pageIndex">The index of page.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <param name="keyword">The searched key word.</param>
        /// <returns>The loaded admins</returns>
        public async Task<List<Account>> GetAccountsAsync(long sessionId, int pageIndex, int pageSize, string keyword, Role role)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    return await accountDataManager.GetAccountsAsync(pageIndex, pageSize, keyword, session.IsRoot, session.Organizations, role);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get total admin count.
        /// </summary>
        /// <param name="keyword">The searched key word.</param>
        /// <returns>The admin count.</returns>
        public async Task<int> GetAccountCountAsync(long sessionId, string keyword, Role role)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    return (int)await accountDataManager.GetAccountCountAsync(keyword, session.IsRoot, session.Organizations, role);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the admin by admin id.
        /// </summary>
        /// <param name="adminId">The id of the admin</param>
        /// <returns>The admin</returns>
        public async Task<Account> GetAccountAsync(long sessionId, long adminId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var admin = await accountDataManager.GetAccountAsync(adminId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get admins by id {adminId}.");
                    return admin;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Create a admin in system.
        /// </summary>
        /// <param name="sessionId">The session of current admin</param>
        /// <param name="name">The name of the admin</param>
        /// <param name="fullName">The full name of the admin</param>
        /// <param name="password">The password of the admin</param>
        /// <returns>The created admin</returns>
        public async Task<Account> CreateAccountAsync(long sessionId, string name, string fullName, string password, List<EntityBase> organizations, List<Role> roles, List<AuthorityBase> authorities,
            DeveloperAuthorityInfo developerAuthorityInfo, LabelerAuthorityInfo labelerAuthorityInfo, int handyToolExportDelay, List<SupportedDataType> supportedDataTypes)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var account = await accountDataManager.GetAccountAsync(name);
                    if (account == null)
                    {
                        //Get the default authorities
                        account = new Account
                        {
                            Name = name,
                            FullName = fullName,
                            Password = password.ToMd5(),
                            IsRoot = false,
                            Organizations = organizations,
                            Roles = roles,
                            AdminAuthorities = authorities,
                            DeveloperAuthorityInfo = developerAuthorityInfo,
                            LabelerAuthorityInfo = labelerAuthorityInfo,
                            HandyToolExportDelay = handyToolExportDelay,
                            SupportedDataTypes = supportedDataTypes,
                        };
                        await accountDataManager.CreateAccountAsync(account);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} created admin {account.Name}, roles {JsonConvert.SerializeObject(roles)}");
                        return account;
                    }

                    throw new InvalidOperationException("DuplicateName");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update one admin.
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="id"></param>
        /// <returns>Void</returns>
        public async Task UpdateAccountAsync(long sessionId, long id, string fullName, List<EntityBase> organizations, List<Role> roles, List<AuthorityBase> authorities,
            DeveloperAuthorityInfo developerAuthorityInfo, LabelerAuthorityInfo labelerAuthorityInfo, int handyToolExportDelay, List<SupportedDataType> supportedDataTypes)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var account = await accountDataManager.GetAccountAsync(id);
                    if (account != null)
                    {
                        account.FullName = fullName;
                        account.Organizations = organizations;
                        account.Roles = roles;
                        account.AdminAuthorities = authorities;
                        account.DeveloperAuthorityInfo = developerAuthorityInfo;
                        account.LabelerAuthorityInfo = labelerAuthorityInfo;
                        account.HandyToolExportDelay = handyToolExportDelay;
                        account.SupportedDataTypes = supportedDataTypes;
                        await accountDataManager.UpdateAccountAsync(account);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} updated admin {account.Name}, roles {JsonConvert.SerializeObject(roles)}");
                    }
                    else
                    {
                        throw new InvalidOperationException("AdminNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Update a admin password.
        /// </summary>
        /// <param name="sessionId">The session id of current admin.</param>
        /// <param name="id">The admin id of the admin to operated.</param>
        /// <param name="password">The password of the admin.</param>
        /// <returns>Void</returns>
        public async Task UpdateAccountPasswordAsync(long sessionId, long id, string password)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    if (!string.IsNullOrEmpty(password) && !string.IsNullOrWhiteSpace(password))
                    {
                        password = password.Trim().ToMd5();
                    }
                    await accountDataManager.UpdateAccountPasswordAsync(id, password);
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Delete one admin from the system.
        /// </summary>
        /// <param name="sessionId">The session id of current admin.</param>
        /// <param name="adminId">The admin id of the admin to process</param>
        /// <returns>Void</returns>
        public async Task DeleteAccountAsync(long sessionId, long adminId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var admin = await accountDataManager.GetAccountAsync(adminId);
                    if (admin != null)
                    {
                        await accountDataManager.DeleteAccountAsync(adminId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted admin {admin.Name}");
                    }
                    else
                    {
                        throw new InvalidOperationException("AdminNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get total developer count.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <returns>The developer count.</returns>
        public async Task<int> GetDeveloperCountAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var count = await developerDataManager.GetDeveloperCountAsync(keyword, session.IsRoot, session.Organizations);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get developer count from system.");
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all developers from system
        /// </summary>
        /// <returns>The loaded developers.</returns>
        public async Task<List<DeveloperAccount>> GetDevelopersAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    return await developerDataManager.GetDevelopersAsync();
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all developers from the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="pageIndex">The page index of result.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>The developers in the system</returns>
        public async Task<List<DeveloperAccount>> GetDevelopersAsync(long sessionId, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developers = await developerDataManager.GetDevelopersAsync(pageIndex, pageSize);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get {developers.Count} developers in page {pageIndex}.");
                    return developers;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Find a developer by search key.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="key">The search key.</param>
        /// <param name="pageIndex">The page index of result.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>The found developers.</returns>

        public async Task<List<DeveloperAccount>> FindDevelopersAsync(long sessionId, string key, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developers = await developerDataManager.GetDevelopersAsync(key, pageIndex, pageSize, session.IsRoot, session.Organizations);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} found {developers.Count} developers for search key {key} in page {pageIndex}.");
                    return developers;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Create a developer in system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="name">The name of the developer.</param>
        /// <param name="fullName">The full name of the developer.</param>
        /// <param name="password">The password of the developer.</param>
        /// <returns>The created developer.</returns>
        public async Task<DeveloperAccount> CreateDeveloperAsync(long sessionId, string name, string fullName, string password, DateTime expireTime, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developer = await developerDataManager.GetDeveloperAsync(name);
                    if (developer == null)
                    {
                        developer = new DeveloperAccount
                        {
                            Name = name,
                            FullName = fullName,
                            Password = password.ToMd5(),
                            WorkTokenId = Guid.NewGuid().ToString("N"),
                            WorkTokenExpireTime = expireTime,
                            Organizations = organizations,
                        };
                        await developerDataManager.CreateDeveloperAsync(developer);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} created developer {developer.Name}.");
                        return developer;
                    }
                    throw new InvalidOperationException("DeveloperAlreadyExists");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update one developer account.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="id">The id of developer to handle.</param>
        /// <param name="fullName">The full name of the developer.</param>
        /// <param name="expireTime">The token expire time.</param>
        /// <returns>Void</returns>
        public async Task UpdateDeveloperAsync(long sessionId, long id, string fullName, DateTime expireTime, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developer = await developerDataManager.GetDeveloperAsync(id);
                    if (developer != null)
                    {
                        developer.FullName = fullName;
                        developer.WorkTokenExpireTime = expireTime;
                        developer.Organizations = organizations;
                        await developerDataManager.UpdateDeveloperAsync(developer);
                    }
                    else
                    {
                        throw new InvalidOperationException("DeveloperNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Update one developer password.
        /// </summary>
        /// <param name="id">The id of developer to handle.</param>
        /// <param name="password">The password of the developer.</param>
        /// <returns>Void</returns>
        public async Task UpdateDeveloperPasswordAsync(long sessionId, long id, string password)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developer = await developerDataManager.GetDeveloperAsync(id);
                    if (developer != null)
                    {
                        if (!string.IsNullOrWhiteSpace(password) && !string.IsNullOrEmpty(password))
                        {
                            developer.Password = password.Trim().ToMd5();
                        }

                        await developerDataManager.UpdateDeveloperPasswordAsync(id, password);
                    }
                    else
                    {
                        throw new InvalidOperationException("DeveloperNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Delete one developer from the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="developerId">The developer id of the developer to process</param>
        /// <returns>Void</returns>
        public async Task DeleteDeveloperAsync(long sessionId, long developerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developer = await developerDataManager.GetDeveloperAsync(developerId);
                    if (developer != null)
                    {
                        await developerDataManager.DeleteDeveloperAsync(developerId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted developer {developer.Name}");
                    }
                    else
                    {
                        throw new InvalidOperationException("DeveloperNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Create a token for a developer.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="developerId">The developer id of the developer to process</param>
        /// <param name="expireTime">The expired time for the token.</param>
        /// <returns>The created token.</returns>
        public async Task<string> CreateTokenAsync(long sessionId, long developerId, DateTime expireTime)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developer = await developerDataManager.GetDeveloperAsync(developerId);
                    if (developer == null)
                    {
                        throw new InvalidOperationException("DeveloperNotExist");
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} create WorkToken({expireTime}) for developer {developer.Name}.");
                    return await developerDataManager.CreateWorkToken(developerId, expireTime);
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete work token.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="developerId">The id of the developer.</param>
        /// <returns></returns>
        public async Task DeleteWorkTokenAsync(long sessionId, long developerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerDataManager = databaseService.GetManager<IDeveloperDataManager>();
                    var developer = await developerDataManager.GetDeveloperAsync(developerId);
                    if (developer == null)
                    {
                        throw new InvalidOperationException("DeveloperNotExist");
                    }
                    await developerDataManager.DeleteWorkTokenAsync(developerId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted WorkToken for developer {developer.Name}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get total labeler count.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="keyword">The searched keyword.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>The labeler count.</returns>
        public async Task<int> GetLabelerCountAsync(long sessionId, string keyword, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeler count from system from {start.Date} to {end.Date}.");
                    return (int)await labelerDataManager.GetLabelerCountAsync(keyword, start, end);
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeler by labeler id.
        /// </summary>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <returns>The found labeler.</returns>
        public async Task<LabelerAccount> GetLabelerAsync(long sessionId, long labelerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    return await labelerDataManager.GetLabelerAsync(labelerId);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all labelers.
        /// </summary>
        /// <returns>LabelerAccounts from the system.</returns>
        public async Task<List<LabelerAccount>> GetLabelersAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                var result = await labelerDataManager.GetLabelersAsync(session.IsRoot, session.Organizations);
                return result;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get senior labelers from the system.
        /// </summary>
        public async Task<List<LabelerAccount>> GetSeniorLabelersAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var result = await labelerDataManager.GetSeniorLabelersAsync(session.IsRoot, session.Organizations);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get senior labelers from system.");
                    return result;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the labelers by search key.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="key">The search key.</param>
        /// <param name="pageIndex">The page index of result.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>The found labelers.</returns>
        public async Task<List<LabelerAccount>> GetLabelersAsync(long sessionId, string key, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var result = await labelerDataManager.GetLabelersAsync(key, pageIndex, pageSize, session.IsRoot, session.Organizations);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of labelers with key {key} from system.");
                    return result;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the labelers by search key.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="key">The search key.</param>
        /// <param name="pageIndex">The page index of result.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>The found labelers.</returns>
        public async Task<List<LabelerAccount>> GetLabelersAsync(long sessionId, string key, int pageIndex, int pageSize, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var result = await labelerDataManager.GetLabelersAsync(key, pageIndex, pageSize, session.IsRoot, session.Organizations, start, end);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of labelers with key {key} from system.");
                    return result;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Create a labeler in system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="name">The name of the labeler.</param>
        /// <param name="fullName">The full name of the labeler.</param>
        /// <param name="password">The password of the labeler.</param>
        /// <param name="comeFrom">Where the labeler come from</param>
        /// <param name="qualification">The qualification of the labeler</param>
        /// <param name="seniorLabeler">The teacher of the labeler</param>
        /// <param name="organizations">The organizations of the labeler</param>
        /// <returns>The created labeler.</returns>
        public async Task<LabelerAccount> CreateLabelerAsync(long sessionId, string name, string fullName, string password, string comeFrom, string qualification, bool isRemote, EntityBase seniorLabeler, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var labeler = await labelerDataManager.GetLabelerAsync(name);
                    if (labeler == null)
                    {
                        labeler = new LabelerAccount
                        {
                            Name = name,
                            FullName = fullName,
                            Password = password.ToMd5(),
                            ComeFrom = comeFrom,
                            Qualification = qualification,
                            IsRemote = isRemote,
                            Teacher = seniorLabeler,
                            Organizations = organizations,
                        };
                        await labelerDataManager.CreateLabelerAsync(labeler);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} created labeler {labeler.Name}.");
                        return labeler;
                    }
                    throw new InvalidOperationException("LabelerAlreadyExists");
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update a labeler
        /// </summary>
        /// <param name="id">The id of the labeler</param>
        /// <param name="fullName">The full name of the labeler</param>
        /// <param name="level">The level of the labeler</param>
        /// <param name="comeFrom">where the labeler come from</param>
        /// <param name="qualification">The qualification of the labeler</param>
        /// <param name="seniorLabeler">The teacher of the labeler</param>
        /// <param name="organizations">The organizations of the labeler</param>
        /// <returns></returns>
        public async Task UpdateLabelerAsync(long sessionId, long id, string fullName, string comeFrom, string qualification, bool isRemote, EntityBase seniorLabeler, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var labeler = await labelerDataManager.GetLabelerAsync(id);
                    if (labeler != null)
                    {
                        labeler.FullName = fullName;
                        labeler.ComeFrom = comeFrom;
                        labeler.Qualification = qualification;
                        labeler.Teacher = seniorLabeler;
                        labeler.Organizations = organizations;
                        labeler.IsRemote = isRemote;
                        await labelerDataManager.UpdateLabelerAsync(labeler);
                    }
                    else
                    {
                        throw new InvalidOperationException("LabelerNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Update a labeler password.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="labelerId">The labeler id of the labeler to operated.</param>
        /// <param name="password">The password of the labeler.</param>
        /// <returns>Void</returns>
        public async Task UpdateLabelerPasswordAsync(long sessionId, long labelerId, string password)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var labeler = await labelerDataManager.GetLabelerAsync(labelerId);
                    if (labeler != null)
                    {
                        if (!string.IsNullOrEmpty(password) && !string.IsNullOrEmpty(password))
                        {
                            password = password.Trim().ToMd5();
                        }

                        await labelerDataManager.UpdateLabelerPasswordAsync(labelerId, password);
                    }
                    else
                    {
                        throw new InvalidOperationException("LabelerNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Delete one labeler from the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="labelerId">The labeler id of the labeler to process</param>
        /// <returns>Void</returns>
        public async Task DeleteLabelerAsync(long sessionId, long labelerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var labeler = await labelerDataManager.GetLabelerAsync(labelerId);
                    if (labeler != null)
                    {
                        await labelerDataManager.DeleteLabelerAsync(labelerId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted labeler {labeler.Name}.");
                    }
                    else
                    {
                        throw new InvalidOperationException("LabelerNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Register a agent into the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="agentVersion">The version of the agent</param>
        /// <param name="agentName">The name of the agent.</param>
        /// <param name="description">The description of the agent.</param>
        /// <param name="hardwareCode">The hardware code of the agent.</param>
        /// <param name="ipAddress">The ip address of the agent.</param>
        /// <returns>Void</returns>
        public async Task RegisterAgentAsync(long sessionId, string agentVersion, string agentName, string description, string hardwareCode, string ipAddress, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var agentDataManager = databaseService.GetManager<IAgentDataManager>();
                    var current = await agentDataManager.GetAgentAsync(hardwareCode);
                    if (current != null)
                    {
                        throw new InvalidOperationException("AgentAlreadyExists");
                    }

                    //var deleted = await agentDataManager.GetDeletedAgentAsync(hardwareCode);
                    //if (deleted != null)
                    //{
                    //    await agentDataManager.RestoreAgentAsync(deleted.Id);
                    //}
                    //else
                    {
                        var agent = new Agent
                        {
                            Version = agentVersion,
                            Name = agentName,
                            Description = description,
                            HardwareCode = hardwareCode,
                            IpAddress = ipAddress,
                            Organizations = organizations,
                        };
                        await agentDataManager.CreateAgentAsync(agent);
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} register agent {agentName}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Un-register an agent from the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="agentId">The agent id to un-register</param>
        /// <returns>Void</returns>
        public async Task UnRegisterAgentAsync(long sessionId, long agentId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var agentDataManager = databaseService.GetManager<IAgentDataManager>();
                    var agent = await agentDataManager.GetAgentAsync(agentId);
                    if (agent == null)
                    {
                        throw new InvalidOperationException("AgentNotExist");
                    }
                    await agentDataManager.DeleteAgentAsync(agentId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} un-register agent {agent.Name}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Update agent organizations from the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="agentId">The agent id</param>
        /// <param name="organizations">The organizations to update</param>
        /// <returns>Void</returns>
        public async Task UpdateAgentOrganizationsAsync(long sessionId, long agentId, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var agentDataManager = databaseService.GetManager<IAgentDataManager>();
                    var agent = await agentDataManager.GetAgentAsync(agentId);
                    if (agent == null)
                    {
                        throw new InvalidOperationException("AgentNotExist");
                    }
                    await agentDataManager.UpdateAgentOrganizationsAsync(agentId, organizations);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} update organizations {JsonConvert.SerializeObject(organizations.Select(x => x.Name))} of agent {agent.Name}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get all agents from the system.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <returns>The agents in the system</returns>
        public async Task<List<AgentInfoEx>> GetAgentsAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var agentDataManager = databaseService.GetManager<IAgentDataManager>();
                    var registeredAgents = await agentDataManager.GetAgentsAsync(session.IsRoot, session.Organizations);
                    var onlineAgents = OnlineAgentManager.GetOnlineAgents(session.IsRoot, session.Organizations);
                    var agentList = new List<AgentInfoEx>();
                    foreach (var registeredAgent in registeredAgents)
                    {
                        var agentInfoEx = new AgentInfoEx
                        {
                            Id = registeredAgent.Id,
                            Name = registeredAgent.Name,
                            Version = registeredAgent.Version,
                            Online = false,
                            Registered = true,
                            Description = registeredAgent.Description,
                            IpAddress = registeredAgent.IpAddress,
                            HardwareCode = registeredAgent.HardwareCode,
                            Organizations = registeredAgent.Organizations,
                        };
                        agentList.Add(agentInfoEx);
                    }

                    foreach (var onlineAgent in onlineAgents)
                    {
                        var agentInfoEx = agentList.FirstOrDefault(x => x.HardwareCode == onlineAgent.HardwareCode && x.IpAddress == onlineAgent.IpAddress);
                        if (agentInfoEx == null)
                        {
                            agentInfoEx = new AgentInfoEx
                            {
                                Id = -1,
                                Name = onlineAgent.Name,
                                Version = onlineAgent.Version,
                                Online = true,
                                Registered = false,
                                Description = string.Empty,
                                IpAddress = onlineAgent.IpAddress,
                                HardwareCode = onlineAgent.HardwareCode,
                                WorkingState = onlineAgent.WorkingState,
                            };
                            agentList.Add(agentInfoEx);
                        }
                        else
                        {
                            agentInfoEx.Online = true;
                            agentInfoEx.WorkingState = onlineAgent.WorkingState;
                        }
                        agentInfoEx.MemoryInfo = onlineAgent.MemoryInfo;
                        agentInfoEx.DiskInfo = onlineAgent.DiskInfo;
                        agentInfoEx.CpuInfo = onlineAgent.CpuInfo;
                        agentInfoEx.GpuInfo = onlineAgent.GpuInfo;
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get all agents.");
                    return agentList;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the agents count from the system.
        /// </summary>
        /// <returns>Void</returns>
        public async Task<int> GetAgentsCountAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var agentDataManager = databaseService.GetManager<IAgentDataManager>();
                    var count = await agentDataManager.GetAgentsCountAsync(session.IsRoot, session.Organizations);
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get ultrasound groups count by image category id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The image category id.</param>
        /// <returns>Total group count</returns>
        public async Task<int> GetUltrasoundGroupCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var count = await ultrasoundGroupDataManager.GetUltrasoundGroupCountAsync(imageCategory.Level, imageCategoryId, keyword);
                        return (int)count;
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeled group count.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="imageCategoryId">The image category id to handle.</param>
        /// <returns>The group count.</returns>
        public async Task<int> GetLabeledGroupCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        return (int)await ultrasoundGroupDataManager.GetLabeledUltrasoundGroupCountAsync(imageCategory.Level, imageCategoryId, keyword);
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get un-labeled group count.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="imageCategoryId">The image category id to handle.</param>
        /// <returns>The group count.</returns>
        public async Task<int> GetUnLabeledGroupCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        return (int)await ultrasoundGroupDataManager.GetUnLabeledUltrasoundGroupCountAsync(imageCategory.Level, imageCategoryId, keyword);
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get gold standard groups count by image category id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The image category id.</param>
        /// <returns>Total group count</returns>
        public async Task<int> GetGoldStandardGroupCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var count = await ultrasoundGroupDataManager.GetGoldStandardUltrasoundGroupCountAsync(imageCategory.Level, imageCategoryId, keyword);
                        return (int)count;
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeled file count.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="imageCategoryId">The image category id to handle.</param>
        /// <returns>The image count.</returns>
        public async Task<int> GetLabeledFileCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        return (int)await ultrasoundFileDataManager.GetLabeledUltrasoundFileCountAsync(imageCategory.Level, imageCategoryId, null, keyword);
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }
        /// <summary>
        /// Get Dispute labeled file count.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="imageCategoryId">The image category id to handle.</param>
        /// <returns>The image count.</returns>
        public async Task<int> GetDisputeLabeledFileCountAsync(long sessionId, long imageCategoryId, string keyword, bool isAssign, string keyWordLabele)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    try
                    {
                        var databaseService = ServiceManager.GetService<IDatabaseService>();
                        var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                        var DisputeultrasoundFileDataManager = databaseService.GetManager<IDisputeUltrasoundFileDataManager>();
                        var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                        if (imageCategory != null)
                        {
                            return (int)await DisputeultrasoundFileDataManager.GetLabeledUltrasoundFileCountAsync(imageCategory.Level, imageCategoryId, keyword, isAssign, keyWordLabele);
                        }
                    }
                    catch (Exception ex)
                    {
                        return 0;
                    }

                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeler statistic data.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>The labeler statistic data.</returns>
        public async Task<LabelerStatisticData> GetLabelerStatisticDataAsync(long sessionId, long labelerId, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var labelCaseStatisticDataManager = databaseService.GetManager<ILabelCaseStatisticDataManager>();
                    var labelCaseStatistics = await labelCaseStatisticDataManager.GetLabelCaseStatisticsAsync(labelerId, start, end);
                    var assignCases = await caseDataManager.GetAssignedLabelCasesAsync(labelerId, start, end);
                    var accuracy = 0d;
                    var consistency = 0d;
                    var conflictRate = 0d;
                    var conflictAccuracy = 0d;
                    if (labelCaseStatistics.Count > 0)
                    {
                        var totalImagesCount = labelCaseStatistics.Select(s => s.Count).Sum();
                        var totalGoldStandardCount = labelCaseStatistics.Select(s => s.GoldStandard.Total).Sum();
                        var totalConsistentGoldStandardCount = labelCaseStatistics.Select(s => s.GoldStandard.ConsistentCount).Sum();
                        var totalDuplicateImagesCount = labelCaseStatistics.Select(s => s.SelfCheck.Total).Sum();
                        var totalConsistentDuplicateImagesCount = labelCaseStatistics.Select(s => s.SelfCheck.ConsistentCount).Sum();
                        if (totalGoldStandardCount > 0)
                        {
                            accuracy = (double)Math.Round((decimal)totalConsistentGoldStandardCount / totalGoldStandardCount, 3);
                        }

                        if (totalDuplicateImagesCount > 0)
                        {
                            consistency = (double)Math.Round((decimal)totalConsistentDuplicateImagesCount / totalDuplicateImagesCount, 3);
                        }
                    }

                    var alllabelCaseStatistics = new List<LabelCaseStatistic>();
                    foreach (var assignCase in assignCases)
                    {
                        var labelCaseStatistic = labelCaseStatistics.FirstOrDefault(s => s.AssignedLabelCaseId == assignCase.Id);
                        if (labelCaseStatistic == null)
                        {
                            var totalImageCount = (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(assignCase.Id);
                            labelCaseStatistic = new LabelCaseStatistic
                            {
                                Name = assignCase.Name,
                                SameBatchLabelCaseId = assignCase.SameBatchLabelCaseId,
                                AssignedLabelCaseId = assignCase.Id,
                                Labeler = assignCase.Labeler,
                                Count = totalImageCount
                            };
                            alllabelCaseStatistics.Add(labelCaseStatistic);
                        }
                        else
                        {
                            alllabelCaseStatistics.Add(labelCaseStatistic);
                        }
                    }

                    return new LabelerStatisticData
                    {
                        Accuracy = accuracy,
                        Consistency = consistency,
                        ConflictRate = conflictRate,
                        ConflictAccuracy = conflictAccuracy,
                        LabelCaseStatistics = alllabelCaseStatistics
                    };
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get SameBatchLabelCase  statistics by case id..
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="caseId">The id of the SameBatchLabelCase.</param>
        /// <returns>The SameBatchLabelCase general statistics.</returns>
        public async Task<SameBatchLabelCaseStatisticData> GetSameBatchLabelCaseStatisticsAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(caseId);
                    if (sameBatchLabelCase == null || sameBatchLabelCase.Labelers.Count < 1)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }

                    var totalImageCount = (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(sameBatchLabelCase.Labelers.FirstOrDefault().AssignedLabelCaseId);
                    var finishedLabelCount = sameBatchLabelCase.Labelers.Count(x => x.State == ReviewState.Completed);
                    var unfinishedLabelCount = sameBatchLabelCase.Labelers.Count - finishedLabelCount;
                    var conflictImageCount = 0;
                    if (sameBatchLabelCase.InconsistentInfos != null)
                    {
                        conflictImageCount = sameBatchLabelCase.InconsistentInfos.Count;
                    }
                    //foreach (var labelCaseId in sameBatchLabelCase.LabelCaseIds)
                    //{
                    //    var labelCaseStatistics = await caseDataManager.GetLabelCaseStatisticsByCaseIdAsync(labelCaseId);
                    //    if (labelCaseStatistics != null)
                    //    {
                    //        conflictImageCount = labelCaseStatistics.ConflictImagesCount;
                    //    }
                    //}
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var reviewCaseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    List<ReviewedExtendInfo> reviewedInfos = null;
                    if (sameBatchLabelCase.Reviewers != null)
                    {
                        reviewedInfos = new List<ReviewedExtendInfo>();
                        foreach (var reviewer in sameBatchLabelCase.Reviewers)
                        {
                            var account = await accountDataManager.GetAccountAsync(reviewer.Id);
                            var index = await reviewCaseDataManager.GetLastReviewedCaseFileIndexAsync(reviewer.Id, sameBatchLabelCase.Id);
                            var reviewInfo = new ReviewedExtendInfo
                            {
                                Reviewer = account?.Name,
                                //ReviewedImageCount = index + 1
                                ReviewedImageCount = index > 0 ? index + 1 : index,
                            };
                            reviewedInfos.Add(reviewInfo);
                        }
                    }
                    return new SameBatchLabelCaseStatisticData
                    {
                        TotalImageCount = totalImageCount,
                        SameBatchLabelCase = sameBatchLabelCase,
                        FinishedLablerCount = finishedLabelCount,
                        UnFinishedLablerCount = unfinishedLabelCount,
                        ConflictImageCount = conflictImageCount,
                        State = sameBatchLabelCase.State,
                        ReviewedInfos = reviewedInfos,
                    };
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeler statistics by case id..
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="caseId">The id of the label case.</param>
        /// <returns>The labeler statistics.</returns>
        public async Task<LabelCaseStatistic> GetLabelCaseStatisticAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var labelCaseStatisticsDataManager = databaseService.GetManager<ILabelCaseStatisticDataManager>();
                    var labelCaseStatistic = await labelCaseStatisticsDataManager.GetLabelCaseStatisticByCaseIdAsync(caseId);
                    var assignCase = await caseDataManager.GetAssignedLabelCaseAsync(caseId);
                    if (labelCaseStatistic == null)
                    {
                        var totalImageCount = (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(assignCase.Id);
                        labelCaseStatistic = new LabelCaseStatistic
                        {
                            Name = assignCase.Name,
                            SameBatchLabelCaseId = assignCase.SameBatchLabelCaseId,
                            AssignedLabelCaseId = assignCase.Id,
                            Labeler = assignCase.Labeler,
                            Count = totalImageCount
                        };
                    }

                    return labelCaseStatistic;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeler case statistics by the same batch label case id
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="sameBatchLabelCaseId">The same batch label case id</param>
        /// <returns></returns>
        public async Task<List<LabelCaseStatistic>> GetLabelCaseStatisticsBySameBatchLabelCaseIdAsync(long sessionId, long sameBatchLabelCaseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelCaseStatisticsDataManager = databaseService.GetManager<ILabelCaseStatisticDataManager>();
                    var labelCaseStatistics = await labelCaseStatisticsDataManager.GetLabelCaseStatisticsBySameBatchLabelCaseIdAsync(sameBatchLabelCaseId);
                    return labelCaseStatistics;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update labeled ultrasound image.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labeledImageId">The labeled ultrasound image id.</param>
        /// <param name="isGoldStandard">The value to indicate whether the labeled file is gold standard or not.</param>
        public async Task UpdateLabeledUltrasoundFileAsync(long sessionId, long labeledImageId, bool isGoldStandard)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileAsync(labeledImageId);
                    if (labeledUltrasoundFile == null)
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }

                    labeledUltrasoundFile.IsGoldStandard = isGoldStandard;
                    await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileAsync(labeledUltrasoundFile);
                    var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(labeledUltrasoundFile.UltrasoundFileId);
                    if (ultrasoundFile == null)
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }

                    if (isGoldStandard)
                    {
                        if (ultrasoundFile.GoldStandardLabeledFileId != -1)
                        {
                            var oldGoldStandardFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileAsync(ultrasoundFile.GoldStandardLabeledFileId);
                            if (oldGoldStandardFile != null)
                            {
                                oldGoldStandardFile.IsGoldStandard = false;
                                await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileAsync(oldGoldStandardFile);
                            }
                        }
                        ultrasoundFile.GoldStandardLabeledFileId = labeledUltrasoundFile.Id;
                    }
                    else
                    {
                        ultrasoundFile.GoldStandardLabeledFileId = -1;
                    }
                    await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Update labeled ultrasound image's is adoptable state.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labeledUltrasoundFileId">The id of the ultrasound image.</param>
        /// <param name="isAdoptable">The value to indicate whether the labeled file is adoptable or not.</param>
        /// <returns></returns>
        public async Task UpdateLabeledUltrasoundFileIsAdoptableAsync(long sessionId, long labeledUltrasoundFileId, bool isAdoptable)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(labeledUltrasoundFileId);
                    if (labeledUltrasoundFile == null)
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }
                    if (labeledUltrasoundFile.IsAdoptable != isAdoptable)
                    {
                        await UpdateImageCategoryQuantityItemAsync(databaseService, labeledUltrasoundFileDataManager, isAdoptable, labeledUltrasoundFile.UltrasoundFileId, labeledUltrasoundFile.ImageCategoryId);
                        await UpdateImageCategoryQuantityItemAsync(databaseService, labeledUltrasoundFileDataManager, isAdoptable, labeledUltrasoundFile.UltrasoundFileId, labeledUltrasoundFile.ImageBatchId);
                        await UpdateImageCategoryQuantityItemAsync(databaseService, labeledUltrasoundFileDataManager, isAdoptable, labeledUltrasoundFile.UltrasoundFileId, labeledUltrasoundFile.ImageCaseId);

                        labeledUltrasoundFile.IsAdoptable = isAdoptable;
                        await labeledUltrasoundFileDataManager.UpdateIsAdoptableForLabeledUltrasoundFileAsync(labeledUltrasoundFile.Id, isAdoptable);

                        var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                        await UpdateUltrasoundFileAndGroupIsAdoptableAsync(labeledUltrasoundFileDataManager, ultrasoundFileDataManager, ultrasoundGroupDataManager, isAdoptable, labeledUltrasoundFile.UltrasoundFileId, labeledUltrasoundFile.UltrasoundGroupId);
                    }
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        private async Task UpdateImageCategoryQuantityItemAsync(IDatabaseService databaseService, ILabeledUltrasoundFileDataManager labeledUltrasoundFileDataManager, bool newIsAdoptable, long ultrasoundFileId, long imageCategoryId)
        {
            if (imageCategoryId != 0)
            {
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                if (imageCategory != null)
                {
                    var isUpdateImageQuantity = false;
                    var images = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesWithoutIsRelabelAndProjectionAsync(imageCategory.Level, imageCategory.Id, ultrasoundFileId);
                    if (images == null || images.Count == 0)
                    {
                        imageCategory.FileItem.Quantity.Seen++;
                        imageCategory.FileItem.Quantity.Labeled++;
                        imageCategory.FileItem.Quantity.UnLabeled--;
                        isUpdateImageQuantity = true;
                    }
                    if (images.Any(x => !x.IsAdoptable) && newIsAdoptable)
                    {
                        imageCategory.FileItem.Quantity.UnAdoptable--;
                        isUpdateImageQuantity = true;
                    }
                    if (!newIsAdoptable)
                    {
                        imageCategory.FileItem.Quantity.UnAdoptable++;
                        isUpdateImageQuantity = true;
                    }
                    if (isUpdateImageQuantity)
                    {
                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageCategory);
                    }
                }
            }
        }

        private static async Task UpdateUltrasoundFileAndGroupIsAdoptableAsync(ILabeledUltrasoundFileDataManager labeledUltrasoundFileDataManager, IUltrasoundFileDataManager ultrasoundFileDataManager, IUltrasoundGroupDataManager ultrasoundGroupDataManager,
            bool newIsAdoptable, long ultrasoundFileId, long ultrasoundGroupId)
        {
            if (newIsAdoptable)
            {
                await ultrasoundFileDataManager.UpdateIsAdoptableForUltrasoundFileAsync(ultrasoundFileId, newIsAdoptable);
                await ultrasoundGroupDataManager.UpdateIsAdoptableForUltrasoundGroupAsync(ultrasoundGroupId, newIsAdoptable);
            }
            else
            {
                var exitAdoptable = await labeledUltrasoundFileDataManager.ExistAdoptableLabeledUltrasoundFileAsync(ultrasoundFileId);
                if (!exitAdoptable)
                {
                    await ultrasoundFileDataManager.UpdateIsAdoptableForUltrasoundFileAsync(ultrasoundFileId, newIsAdoptable);
                }
                var exitFileAdoptable = await ultrasoundFileDataManager.ExistAdoptableUltrasoundFileAsync(ultrasoundGroupId);
                if (!exitFileAdoptable)
                {
                    await ultrasoundGroupDataManager.UpdateIsAdoptableForUltrasoundGroupAsync(ultrasoundGroupId, newIsAdoptable);
                }
            }
        }

        /// <summary>
        /// Get un-labeled file count.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="imageCategoryId">The tag to handle.</param>
        /// <returns>The image count.</returns>
        public async Task<int> GetUnLabeledFileCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        return (int)await ultrasoundFileDataManager.GetUnLabeledUltrasoundFileCountAsync(imageCategory.Level, imageCategoryId, null, keyword);
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        private async Task<ArchivedImage> GetOrCreateArchivedImage(long organinzationId, byte[] imageData, ImageSource source, ImageDataFormat format, int width, int height)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var archivedImageDataManager = databaseService.GetManager<IArchivedImageDataManager>();
            var hashCode = imageData.ToMd5();
            var archivedImage = await archivedImageDataManager.GetArchivedImageAsync(organinzationId, hashCode);
            if (archivedImage == null)
            {
                archivedImage = new ArchivedImage
                {
                    OrganizationId = organinzationId,
                    OriginalName = source.FileName,
                    ImageData = imageData,
                    Format = format,
                    Width = width,
                    Height = height,
                    HashCode = hashCode,
                    FrameCount = 1,
                };
                await archivedImageDataManager.CreateArchivedImageAsync(archivedImage);
            }
            return archivedImage;
        }

        private async Task<ArchivedImage> GetOrCreateArchivedImageByVideo(long organinzationId, string filePath, ImageSource source, ImageDataFormat format)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var archivedImageDataManager = databaseService.GetManager<IArchivedImageDataManager>();
            var fileData = File.ReadAllBytes(filePath);
            var hashCode = fileData.ToMd5();
            var archivedImage = await archivedImageDataManager.GetArchivedImageAsync(organinzationId, hashCode);
            if (archivedImage == null)
            {
                archivedImage = new ArchivedImage
                {
                    OrganizationId = organinzationId,
                    OriginalName = source.FileName,
                    Format = format,
                    HashCode = hashCode,
                };

                #region Save Video

                // Avi转为Mp4
                var isAvi = Path.GetExtension(filePath) == ".avi";
                if (isAvi)
                {
                    var convertFileName = Path.GetFileNameWithoutExtension(filePath);
                    var convertFileNameMp4 = $"{convertFileName}.mp4";
                    var convertFilePath = Path.Combine(CommonConfigManager.VideoBatchSizeFolder, convertFileNameMp4);
                    VideoHelper.ConvertAviToMp4(filePath, convertFilePath);
                    FileUtils.DeleteFile(filePath);
                    filePath = convertFilePath;
                }

                // 视频转码，转成了H264编码
                var transcodingFolder = Path.Combine(CommonConfigManager.VideoTranscodingFolder, archivedImage.Id.ToString());
                if (!Directory.Exists(transcodingFolder))
                {
                    Directory.CreateDirectory(transcodingFolder);
                }
                var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(source.FileName);
                archivedImage.OriginalName = $"{fileNameWithoutExtension}.mp4";
                var transcodingFilePath = Path.Combine(transcodingFolder, archivedImage.OriginalName);
                VideoHelper.TranscodeVideoAsync(filePath, transcodingFilePath);
                FileUtils.DeleteFile(filePath);

                // 视频总帧数
                var frameCount = VideoHelper.GetVideoFrameCountAsync(transcodingFilePath);

                #endregion Save Video

                #region Video Convert FirstImage

                byte[] firstFrameBytes;
                var newFilePath = Path.Combine(CommonConfigManager.VideoTranscodingFolder, archivedImage.Id.ToString(), IdCreator.CreateId() + ".jpg");
                VideoHelper.ConvertFirstImage(transcodingFilePath, newFilePath);
                if (File.Exists(newFilePath))
                {
                    firstFrameBytes = File.ReadAllBytes(newFilePath);
                    File.Delete(newFilePath);
                }
                else
                {
                    return null;
                }
                using (var image = Image.Load(firstFrameBytes))
                {
                    archivedImage.Width = image.Width;
                    archivedImage.Height = image.Height;
                }

                #endregion Video Convert FirstImage

                #region Create ArchivedImage

                archivedImage.ImageData = firstFrameBytes;
                archivedImage.FrameCount = frameCount;
                await archivedImageDataManager.CreateArchivedImageAsync(archivedImage);

                #endregion Create ArchivedImage
            }
            else
            {
                FileUtils.DeleteFile(filePath);
            }
            return archivedImage;
        }

        /// <summary>
        /// 删除一个包含子文件和子文件夹的文件夹及其所有内容
        /// </summary>
        /// <param name="targetDir"></param>
        /// <exception cref="DirectoryNotFoundException"></exception>
        public static void DeleteDirectoryAndContents(string targetDir)
        {
            // 如果目标不是一个存在的目录，则抛出异常  
            if (!Directory.Exists(targetDir))
                throw new DirectoryNotFoundException($"Directory not found: {targetDir}");

            // 获取目录下的所有文件和子目录  
            string[] files = Directory.GetFiles(targetDir);
            string[] subdirectories = Directory.GetDirectories(targetDir);

            // 首先删除所有文件  
            foreach (string file in files)
            {
                File.Delete(file);
            }

            // 然后删除所有子目录  
            foreach (string subdirectory in subdirectories)
            {
                // 递归调用以删除子目录及其内容  
                DeleteDirectoryAndContents(subdirectory);
            }

            // 最后删除目录本身  
            Directory.Delete(targetDir);
        }

        private Dictionary<string, int> _fileBatchSizeIndexDic = new Dictionary<string, int>();

        /// <summary>
        /// 分段上传视频
        /// </summary>
        /// <param name="fileId"></param>
        /// <param name="fileNameWithoutExtension"></param>
        /// <param name="fileBytes"></param>
        /// <returns></returns>
        public async Task<OpResult> UploadVideoBatchSizeAsync(string fileId, string fileNameWithoutExtension, byte[] fileBytes)
        {
            try
            {
                var index = 1;
                if (_fileBatchSizeIndexDic.ContainsKey(fileId))
                {
                    index = _fileBatchSizeIndexDic[fileId] + 1;
                    _fileBatchSizeIndexDic[fileId] = index;
                }
                else
                {
                    _fileBatchSizeIndexDic.Add(fileId, 1);
                }

                var dtoFileName = Regex.Replace(fileNameWithoutExtension, @"\s+", "");
                var fileName = $"{fileId}{dtoFileName}_{index}.dat";
                var filePath = Path.Combine(CommonConfigManager.VideoBatchSizeFolder, fileName);
                await File.WriteAllBytesAsync(filePath, fileBytes);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"AdminService-UploadVideoBatchSizeAsync error: {ex}");
                return new OpResult { ResultCode = OpResultCode.Error, Message = ex.ToString() };
            }

            return new OpResult { ResultCode = OpResultCode.Success };
        }

        /// <summary>
        /// Add un-labeled file into the system.
        /// </summary>
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <param name="imageCategoryId">The image category id</param>
        /// <param name="imageBatchId">The image batch id</param>
        /// <returns>Void</returns>
        public async Task<OpResult> AddUnLabeledFileAsync(long sessionId, long organinzationId, long imageCategoryId, long imageBatchId, UploadFileModel file)
        {
            var result = new OpResult() { ResultCode = OpResultCode.Success };
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                    #region Check if imageCategory is exist

                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory == null)
                    {
                        result.ResultCode = OpResultCode.NotExist;
                        result.Message = $"图像大类不存在";
                        return result;
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId);
                    if (imageBatch == null)
                    {
                        result.ResultCode = OpResultCode.NotExist;
                        result.Message = $"图像批次不存在";
                        return result;
                    }

                    #endregion

                    #region Create UltrasoundGroup

                    var ultrasoundGroup = await ultrasoundGroupDataManager.GetUltrasoundGroupAsync(imageBatchId, file.Group.Name);
                    if (ultrasoundGroup == null)
                    {
                        ultrasoundGroup = new UltrasoundGroup
                        {
                            Name = file.Group.Name,
                            OrganizationId = imageCategory.OrganizationId,
                            ImageCategoryId = imageCategoryId,
                            ImageBatchId = imageBatchId,
                            LabeledTypes = new LabelType[0],
                            Uploader = new EntityBase { Id = session.AccountId, Name = session.Name },
                        };
                        await ultrasoundGroupDataManager.CreateUltrasoundGroupAsync(ultrasoundGroup);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} add un-labeled ultrasound group {ultrasoundGroup.Name}.");
                    }
                    else if (ultrasoundGroup.Assigned)
                    {
                        result.ResultCode = OpResultCode.Assigned;
                        result.Message = $"文件组 {ultrasoundGroup.Name} 已被分配，不可更改其内容";
                        return result;
                    }

                    #endregion

                    var isUpdateGroupCount = ultrasoundGroup.UltrasoundFileInfos.Count == 0;
                    var isUpdateFileCount = false;

                    #region Create ArchivedImage

                    ArchivedImage archivedImage;
                    if (file.IsVideo)
                    {
                        file.Format = ImageDataFormat.Mp4;
                        var videoFilePath = await VideoHelper.MergeVideoBatchFilesAsync(file.FileId, file.FileName, file.FileSize);
                        archivedImage = await GetOrCreateArchivedImageByVideo(organinzationId, videoFilePath, file.Source, file.Format);
                    }
                    else
                    {
                        archivedImage = await GetOrCreateArchivedImage(organinzationId, file.FileData, file.Source, file.Format, file.Width, file.Height);
                    }
                    if (archivedImage == null)
                    {
                        result.ResultCode = OpResultCode.Error;
                        result.Message = $"生成原图失败";
                        return result;
                    }
                    if (Path.GetFileNameWithoutExtension(archivedImage.OriginalName) != Path.GetFileNameWithoutExtension(file.Source.FileName))
                    {
                        var message = $"系统已存在对应原件：{archivedImage?.OriginalName}，不再重复添加 {file.Source.FileName}";
                        //result.Message += message;
                        Logger.WriteLineWarn(message);
                    }

                    #endregion

                    #region Create UltrasoundFile

                    var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileAsync(imageCategoryId, archivedImage.Id);
                    if (ultrasoundFile == null)
                    {
                        var resized = ResizeImageHelper.ResizeImage(archivedImage.ImageData, 192, 192);
                        var previewImage = new LabeledImage
                        {
                            Width = resized.Item1,
                            Height = resized.Item2,
                            ImageData = resized.Item3,
                            Format = file.Format,
                        };
                        ultrasoundFile = new UltrasoundFile
                        {
                            ArchivedImageId = archivedImage.Id,
                            ImageCategoryId = imageCategoryId,
                            ImageBatchId = imageBatchId,
                            UltrasoundGroupId = ultrasoundGroup.Id,
                            Index = ultrasoundGroup.UltrasoundFileInfos.Count,
                            Modal = file.Modal,
                            Source = file.Source,
                            PreviewImage = previewImage,
                            Labeled = false,
                            Assigned = false,
                            LabeledTypes = new LabelType[0],
                            Uploader = new EntityBase { Id = session.AccountId, Name = session.Name },
                            IsVideo = file.IsVideo,
                            FrameCount = archivedImage.FrameCount,
                            GoldStandardLabeledFileId = -1,
                        };
                        await ultrasoundFileDataManager.CreateUltrasoundFileAsync(ultrasoundFile);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} add un-labeled ultrasound file {file.Source.FileName}.");

                        ultrasoundGroup.UltrasoundFileInfos.Add(new UltrasoundFileInfo
                        {
                            Modal = file.Modal,
                            UltrasoundFileId = ultrasoundFile.Id,
                            UltrasoundFileName = file.Source.FileName,
                            IsVideo = file.IsVideo,
                        });
                        isUpdateFileCount = true;
                    }
                    else
                    {
                        var imageBatchExist = await imageCategoryDataManager.GetImageCategoryAsync(ultrasoundFile.ImageBatchId);
                        if (!string.IsNullOrEmpty(result.Message))
                        {
                            result.Message += "\n";
                        }
                        result.Message += $"【原】{imageCategory.Name}-{imageBatchExist?.Name} 下已存在该文件：{ultrasoundFile.Source.FileName}，不再重复添加";
                        result.ResultCode = OpResultCode.DuplicateImage;
                        return result;
                    }

                    #endregion

                    if (isUpdateFileCount)
                    {
                        await ultrasoundGroupDataManager.UpdateUltrasoundGroupAsync(ultrasoundGroup);

                        #region Update Image Quantity

                        if (isUpdateGroupCount)
                        {
                            imageBatch.GroupItem.Quantity.Total++;
                            imageBatch.GroupItem.Quantity.UnLabeled++;
                            imageBatch.GroupItem.Quantity.UnAssigned++;

                            imageCategory.GroupItem.Quantity.Total++;
                            imageCategory.GroupItem.Quantity.UnLabeled++;
                            imageCategory.GroupItem.Quantity.UnAssigned++;
                        }
                        imageBatch.FileItem.Quantity.Total++;
                        imageBatch.FileItem.Quantity.UnLabeled++;
                        imageBatch.FileItem.Quantity.UnAssigned++;

                        var imageBatchModalItem = imageBatch.ModalItems.FirstOrDefault(x => x.Modal.Id == file.Modal.Id || x.Modal.Title == file.Modal.Title);
                        if (imageBatchModalItem == null)
                        {
                            imageBatchModalItem = new ModalQuantityItem
                            {
                                Modal = file.Modal,
                            };
                            imageBatch.ModalItems.Add(imageBatchModalItem);
                        }
                        imageBatchModalItem.Quantity.Total++;
                        imageBatchModalItem.Quantity.UnLabeled++;
                        imageBatchModalItem.Quantity.UnAssigned++;

                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageBatch);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} update imageBatch {imageBatch.Name}, 文件组 {JsonConvert.SerializeObject(imageBatch.GroupItem.Quantity)}, 文件 {JsonConvert.SerializeObject(imageBatch.FileItem.Quantity)}.");

                        imageCategory.FileItem.Quantity.Total++;
                        imageCategory.FileItem.Quantity.UnLabeled++;
                        imageCategory.FileItem.Quantity.UnAssigned++;
                        if (imageCategory.FileItem.GoldStandardQuantity != null && imageCategory.FileItem.GoldStandardQuantity.Proportion > 0)
                        {
                            var total = Math.Round(imageCategory.FileItem.Quantity.Total * imageCategory.FileItem.GoldStandardQuantity.Proportion);
                            imageCategory.FileItem.GoldStandardQuantity.ToBeAdded = (int)total - imageCategory.FileItem.GoldStandardQuantity.Existing;
                        }

                        var imageCategoryModalItem = imageCategory.ModalItems.FirstOrDefault(x => x.Modal.Id == file.Modal.Id || x.Modal.Title == file.Modal.Title);
                        if (imageCategoryModalItem == null)
                        {
                            imageCategoryModalItem = new ModalQuantityItem
                            {
                                Modal = file.Modal,
                            };
                            imageCategory.ModalItems.Add(imageBatchModalItem);
                        }
                        imageCategoryModalItem.Quantity.Total++;
                        imageCategoryModalItem.Quantity.UnLabeled++;
                        imageCategoryModalItem.Quantity.UnAssigned++;

                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageCategory);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} update imageCategory {imageCategory.Name}, 文件组 {JsonConvert.SerializeObject(imageCategory.GroupItem.Quantity)}, 文件 {JsonConvert.SerializeObject(imageCategory.FileItem.Quantity)}.");

                        #endregion Update Image Quantity
                    }
                    //else
                    //{
                    //    result.ResultCode = OpResultCode.NotExist;
                    //    if (!string.IsNullOrEmpty(result.Message))
                    //    {
                    //        result.Message += "\n";
                    //    }
                    //    result.Message += $"文件组 {file.Group.Name} 下无可上传数据";
                    //    return result;
                    //}
                }
                else
                {
                    result.ResultCode = OpResultCode.InvalidSession;
                    result.Message = $"登录时效已过期，请重新登录。";
                }
            }
            else
            {
                result.ResultCode = OpResultCode.InvalidSession;
                result.Message = $"登录时效已过期，请重新登录。";
            }
            return result;
        }

        /// <summary>
        /// Get ultrasound images count by on combination tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <returns>Total image count</returns>
        public async Task<int> GetUltrasoundFileCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var count = await ultrasoundFileDataManager.GetUltrasoundFileCountAsync(imageCategory.Level, imageCategoryId, null, keyword);
                        return (int)count;
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get gold standard images count by on combined tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <returns>Total image count</returns>
        public async Task<int> GetGoldStandardFileCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var count = await ultrasoundFileDataManager.GetGoldStandardUltrasoundFileCountAsync(imageCategory.Level, imageCategoryId, null, keyword);
                        return (int)count;
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get un-gold standard images count by on combined tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <returns>Total image count</returns>
        public async Task<int> GetUnGoldStandardFileCountAsync(long sessionId, long imageCategoryId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var count = await ultrasoundFileDataManager.GetUnGoldStandardUltrasoundFileCountAsync(imageCategory.Level, imageCategoryId, null, keyword);
                        return (int)count;
                    }
                    return 0;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get files by ultrasoundGroupId
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The id of image category.</param>
        /// <param name="ultrasoundGroupId">The id of ultrasound group.</param>
        /// <returns>The loaded files.</returns>
        public async Task<List<PreviewFileModel>> GetUltrasoundFilesByGroupIdAsync(long sessionId, long imageCategoryId, long ultrasoundGroupId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                    var files = new List<PreviewFileModel>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var ultrasoundGroup = await ultrasoundGroupDataManager.GetUltrasoundGroupAsync(ultrasoundGroupId);
                        if (ultrasoundGroup != null)
                        {
                            foreach (var fileInfo in ultrasoundGroup.UltrasoundFileInfos)
                            {
                                if (fileInfo.Labeled)
                                {
                                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLatestLabeledUltrasoundFileWithoutIsRelabelAsync(imageCategory.Level, imageCategoryId, fileInfo.UltrasoundFileId);
                                    if (labeledUltrasoundFile != null)
                                    {
                                        files.Add(new PreviewFileModel
                                        {
                                            UltrasoundGroupId = ultrasoundGroup.Id,
                                            UltrasoundGroupName = ultrasoundGroup.Name,
                                            UltrasoundFileId = labeledUltrasoundFile.UltrasoundFileId,
                                            ArchivedImageId = labeledUltrasoundFile.ArchivedImageId,
                                            Modal = labeledUltrasoundFile.Modal,
                                            IsVideo = labeledUltrasoundFile.IsVideo,
                                            Source = labeledUltrasoundFile.Source,
                                            PreviewImage = labeledUltrasoundFile.PreviewImage,
                                            Labeler = labeledUltrasoundFile.Labeler,
                                            Labeled = true,
                                        });
                                    }
                                }
                                else
                                {
                                    var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileAsync(fileInfo.UltrasoundFileId);
                                    if (ultrasoundFile != null)
                                    {
                                        files.Add(new PreviewFileModel
                                        {
                                            UltrasoundGroupId = ultrasoundGroup.Id,
                                            UltrasoundGroupName = ultrasoundGroup.Name,
                                            UltrasoundFileId = ultrasoundFile.Id,
                                            ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                            Modal = ultrasoundFile.Modal,
                                            IsVideo = ultrasoundFile.IsVideo,
                                            Source = ultrasoundFile.Source,
                                            PreviewImage = ultrasoundFile.PreviewImage,
                                            Labeled = ultrasoundFile.Labeled,
                                        });
                                    }
                                }
                            }
                        }
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get files of level {imageCategory.Level} and {imageCategory.Name} from system");
                    }
                    return files;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get ultrasound images by on combination tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound images</returns>
        public async Task<List<PreviewFileModel>> GetUltrasoundFilesInGroupAsync(long sessionId, long imageCategoryId, string keyword, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                    var files = new List<PreviewFileModel>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var groups = await ultrasoundGroupDataManager.GetUltrasoundGroupsAsync(imageCategory.Level, imageCategoryId, pageIndex, pageSize, keyword);
                        foreach (var group in groups)
                        {
                            if (group.Labeled)
                            {
                                var ultrasoundFile = await ultrasoundFileDataManager.GetFirstLabeledUltrasoundFileAsync(group.Id);
                                if (ultrasoundFile != null)
                                {
                                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLatestLabeledUltrasoundFileWithoutIsRelabelAsync(imageCategory.Level, imageCategoryId, ultrasoundFile.Id);
                                    if (labeledUltrasoundFile != null)
                                    {
                                        files.Add(new PreviewFileModel
                                        {
                                            UltrasoundGroupId = group.Id,
                                            UltrasoundGroupName = group.Name,
                                            UltrasoundFileId = ultrasoundFile.Id,
                                            ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                            Modal = ultrasoundFile.Modal,
                                            IsVideo = ultrasoundFile.IsVideo,
                                            LabeledTypes = ultrasoundFile.LabeledTypes,
                                            Source = labeledUltrasoundFile.Source,
                                            PreviewImage = labeledUltrasoundFile.PreviewImage,
                                            Labeler = labeledUltrasoundFile.Labeler,
                                            Labeled = true,
                                            Uploader = ultrasoundFile.Uploader,
                                            CreateTime = ultrasoundFile.UpdateTime,
                                            UpdateTime = ultrasoundFile.UpdateTime
                                        });
                                    }
                                }
                            }
                            else
                            {
                                var ultrasoundFile = await ultrasoundFileDataManager.GetFirstUltrasoundFileAsync(group.Id);
                                if (ultrasoundFile != null)
                                {
                                    files.Add(new PreviewFileModel
                                    {
                                        UltrasoundGroupId = group.Id,
                                        UltrasoundGroupName = group.Name,
                                        UltrasoundFileId = ultrasoundFile.Id,
                                        ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                        Modal = ultrasoundFile.Modal,
                                        IsVideo = ultrasoundFile.IsVideo,
                                        LabeledTypes = ultrasoundFile.LabeledTypes,
                                        Source = ultrasoundFile.Source,
                                        PreviewImage = ultrasoundFile.PreviewImage,
                                        Labeled = ultrasoundFile.Labeled,
                                        Uploader = ultrasoundFile.Uploader,
                                        CreateTime = ultrasoundFile.CreateTime,
                                        UpdateTime = ultrasoundFile.UpdateTime
                                    });
                                }
                            }
                        }
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get files of level {imageCategory.Level} and {imageCategory.Name} from system");
                    }
                    return files;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get latest labeled files by on combination tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound files</returns>
        public async Task<List<PreviewFileModel>> GetLatestLabeledFilesInGroupAsync(long sessionId, long imageCategoryId, string keyword, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();

                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var files = new List<PreviewFileModel>();
                        var groups = await ultrasoundGroupDataManager.GetUltrasoundGroupsAsync(imageCategory.Level, imageCategoryId, pageIndex, pageSize, keyword);
                        foreach (var group in groups)
                        {
                            var ultrasoundFile = await ultrasoundFileDataManager.GetFirstLabeledUltrasoundFileAsync(group.Id);
                            if (ultrasoundFile != null)
                            {
                                var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLatestLabeledUltrasoundFileWithoutIsRelabelAsync(imageCategory.Level, imageCategoryId, ultrasoundFile.Id);
                                if (labeledUltrasoundFile != null)
                                {
                                    files.Add(new PreviewFileModel
                                    {
                                        UltrasoundGroupId = group.Id,
                                        UltrasoundGroupName = group.Name,
                                        UltrasoundFileId = ultrasoundFile.Id,
                                        ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                        Modal = ultrasoundFile.Modal,
                                        IsVideo = ultrasoundFile.IsVideo,
                                        LabeledTypes = ultrasoundFile.LabeledTypes,
                                        Source = labeledUltrasoundFile.Source,
                                        PreviewImage = labeledUltrasoundFile.PreviewImage,
                                        Labeler = labeledUltrasoundFile.Labeler,
                                        Labeled = true,
                                        Uploader = ultrasoundFile.Uploader,
                                        CreateTime = ultrasoundFile.CreateTime,
                                        UpdateTime = ultrasoundFile.UpdateTime
                                    });
                                }
                            }
                        }
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled files of level {imageCategory.Level} and {imageCategory.Name} from system");
                        return files;
                    }

                    throw new InvalidOperationException("ImageCategoryNotExist");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get unlabeled files by on combination tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound images</returns>
        public async Task<List<PreviewFileModel>> GetUnLabeledFilesInGroupAsync(long sessionId, long imageCategoryId, string keyword, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                    var files = new List<PreviewFileModel>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var groups = await ultrasoundGroupDataManager.GetUltrasoundGroupsAsync(imageCategory.Level, imageCategoryId, pageIndex, pageSize, keyword);
                        foreach (var group in groups)
                        {
                            var ultrasoundFile = await ultrasoundFileDataManager.GetFirstUnLabeledUltrasoundFileAsync(group.Id);
                            if (ultrasoundFile != null)
                            {
                                files.Add(new PreviewFileModel
                                {
                                    UltrasoundGroupId = group.Id,
                                    UltrasoundGroupName = group.Name,
                                    UltrasoundFileId = ultrasoundFile.Id,
                                    ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                    Modal = ultrasoundFile.Modal,
                                    IsVideo = ultrasoundFile.IsVideo,
                                    LabeledTypes = ultrasoundFile.LabeledTypes,
                                    Source = ultrasoundFile.Source,
                                    PreviewImage = ultrasoundFile.PreviewImage,
                                    Labeled = ultrasoundFile.Labeled,
                                    Uploader = ultrasoundFile.Uploader,
                                    CreateTime = ultrasoundFile.CreateTime,
                                    UpdateTime = ultrasoundFile.UpdateTime
                                });
                            }
                        }
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get unlabeled files of level {imageCategory.Level} and {imageCategory.Name} from system");
                    }
                    return files;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get gold standard images by on combination tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound images</returns>
        public async Task<List<PreviewFileModel>> GetGoldStandardFilesInGroupAsync(long sessionId, long imageCategoryId, string keyword, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    //var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();
                    //var reviewedResultDataManager = databaseService.GetManager<IReviewedResultDataManager>();

                    var files = new List<PreviewFileModel>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var groups = await ultrasoundGroupDataManager.GetGoldStandardUltrasoundGroupsAsync(imageCategory.Level, imageCategoryId, pageIndex, pageSize, keyword);
                        foreach (var group in groups)
                        {
                            var ultrasoundFile = await ultrasoundFileDataManager.GetFirstGoldStandardUltrasoundFileAsync(group.Id);
                            if (ultrasoundFile != null)
                            {
                                var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLatestLabeledUltrasoundFileWithoutIsRelabelAsync(imageCategory.Level, imageCategoryId, ultrasoundFile.Id);
                                if (labeledUltrasoundFile != null)
                                {
                                    //var firstFileResultInfo = labeledUltrasoundFile.FileResultInfos.FirstOrDefault();
                                    //var labeledResult = await labeledResultDataManager.GetLabeledResultAsync(firstFileResultInfo.LabeledResultId);
                                    //var reviewerInfos = await GetReviewerInfos(reviewedResultDataManager, firstFileResultInfo);

                                    files.Add(new PreviewFileModel
                                    {
                                        UltrasoundGroupId = group.Id,
                                        UltrasoundGroupName = group.Name,
                                        UltrasoundFileId = ultrasoundFile.Id,
                                        ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                        Modal = ultrasoundFile.Modal,
                                        IsVideo = ultrasoundFile.IsVideo,
                                        LabeledTypes = ultrasoundFile.LabeledTypes,
                                        Source = labeledUltrasoundFile.Source,
                                        PreviewImage = labeledUltrasoundFile.PreviewImage,
                                        Labeler = labeledUltrasoundFile.Labeler,
                                        Labeled = true,
                                        Uploader = ultrasoundFile.Uploader,
                                        CreateTime = ultrasoundFile.CreateTime,
                                        UpdateTime = ultrasoundFile.UpdateTime
                                    });
                                }
                            }
                        }
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get gold standard files of level {imageCategory.Level} and {imageCategory.Name} from system");
                    }
                    return files;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeled files by on combination tag id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound images</returns>
        public async Task<List<LabeledUltrasoundFile>> GetLabeledFilesAsync(long sessionId, long imageCategoryId, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                    var files = new List<LabeledUltrasoundFile>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        files = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesAsync(imageCategory.Level, imageCategoryId, null, pageIndex, pageSize);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled files of level {imageCategory.Level} and imageCategoryId {imageCategoryId} from system");
                    }
                    return files;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get latest labeled files by on combination tag id./Dispute
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound files</returns>
        public async Task<List<PreviewFileModel>> GetDisputeLabeledFilesAsync(long sessionId, long imageCategoryId, string keyword, int pageIndex, int pageSize, bool isAssign, string keyWordLabele)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    //var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();
                    var disputeUltrasoundFileManager = databaseService.GetManager<IDisputeUltrasoundFileDataManager>();

                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var files = new List<PreviewFileModel>();
                        var groups = await disputeUltrasoundFileManager.GetDisputeUltrasoundGroupsAsync(imageCategory.Level, imageCategoryId, pageIndex, pageSize, keyword);
                        foreach (var group in groups)
                        {
                            var ultrasoundFile = await disputeUltrasoundFileManager.GetFirstDisputeUltrasoundFileAsync(group.Id);
                            if (ultrasoundFile != null)
                            {
                                var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLatestLabeledUltrasoundFileWithoutIsRelabelAsync(imageCategory.Level, imageCategoryId, ultrasoundFile.Id);
                                if (labeledUltrasoundFile != null)
                                {
                                    //var firstFileResultInfo = labeledUltrasoundFile.FileResultInfos.FirstOrDefault();
                                    //var labeledResult = await labeledResultDataManager.GetLabeledResultAsync(firstFileResultInfo.LabeledResultId);

                                    files.Add(new PreviewFileModel
                                    {
                                        UltrasoundGroupId = group.Id,
                                        UltrasoundGroupName = group.Name,
                                        UltrasoundFileId = ultrasoundFile.Id,
                                        ArchivedImageId = ultrasoundFile.ArchivedImageId,
                                        Modal = ultrasoundFile.Modal,
                                        IsVideo = ultrasoundFile.IsVideo,
                                        LabeledTypes = ultrasoundFile.LabeledTypes,
                                        Source = labeledUltrasoundFile.Source,
                                        PreviewImage = labeledUltrasoundFile.PreviewImage,
                                        Labeler = labeledUltrasoundFile.Labeler,
                                        Labeled = true,
                                        Uploader = ultrasoundFile.Uploader,
                                        CreateTime = ultrasoundFile.CreateTime,
                                        UpdateTime = ultrasoundFile.UpdateTime,
                                        IsAssignedDispute = ultrasoundFile.IsAssignedDispute
                                    });
                                }
                            }
                        }

                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled files of level {imageCategory.Level} and {imageCategory.Name} from system");
                        return files;
                    }

                    throw new InvalidOperationException("ImageCategoryNotExist");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all labeler infos in the ultrasound file.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="ultrasoundFileId">The id of ultrasound file.</param>
        /// <param name="imageCategoryId">The id of image category.</param>
        /// <returns></returns>
        public async Task<List<LabelerInfo>> GetLabelerInfosAsync(long sessionId, long ultrasoundFileId, long imageCategoryId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                    var infos = new List<LabelerInfo>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var files = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelAsync(imageCategory.Level, imageCategoryId, ultrasoundFileId);
                        foreach (var item in files)
                        {
                            infos.Add(new LabelerInfo
                            {
                                Id = item.Labeler.Id,
                                Name = item.Labeler.Name,
                                LabeledUltrasoundFileId = item.Id,
                                IsAdoptable = item.IsAdoptable,
                                IsGoldStandard = item.IsGoldStandard,
                            });
                        }
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeler infos of ultrasoundFileId {ultrasoundFileId} and level {imageCategory.Level} and imageCategoryId {imageCategoryId} from system");
                    }
                    return infos;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the latest labeled file info for one source file by labeledUltrasoundFileId.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <returns>found ultrasound file</returns>
        public async Task<LabeledUltrasoundFileInfo> GetLatestLabeledUltrasoundFileInfoAsync(long sessionId, long labeledUltrasoundFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();

                    var labeledUltrasoundFileInfo = new LabeledUltrasoundFileInfo();
                    var labeledImage = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileAsync(labeledUltrasoundFileId);
                    await GetLabeledUltrasoundFileInfo(databaseService, labeledImage, labeledUltrasoundFileInfo, true);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get latest labeled ultrasound file  by id {labeledUltrasoundFileId}");
                    return labeledUltrasoundFileInfo;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all the labeled files for one source file by all labelers.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <returns>found ultrasound files</returns>
        public async Task<List<LabeledUltrasoundFileInfo>> GetLabeledUltrasoundFilesByUltrasoundFileIdAsync(long sessionId, long ultrasoundFileId, long imageCategoryId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var assignedLabelCaseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();

                    var labeledUltrasoundFileInfos = new List<LabeledUltrasoundFileInfo>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory != null)
                    {
                        var images = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAsync(imageCategory.Level, imageCategoryId, ultrasoundFileId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled files of UltrasoundFile {ultrasoundFileId} from system");
                        foreach (var labeledImage in images)
                        {
                            var labeledUltrasoundFileInfo = new LabeledUltrasoundFileInfo();
                            await GetLabeledUltrasoundFileInfo(databaseService, labeledImage, labeledUltrasoundFileInfo, true);
                            var assignedLabelCaseFile = await assignedLabelCaseDataManager.GetRelabeledAssignedLabelCaseFileByLabeledUltrasoundFileIdAsync(labeledImage.Id);
                            if (assignedLabelCaseFile != null)
                            {
                                for (int i = 0; i < assignedLabelCaseFile.LabeledUltrasoundFileIds.Count - 1; i++)
                                {
                                    var dic = assignedLabelCaseFile.LabeledUltrasoundFileIds.ElementAt(i);
                                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(dic.Key);
                                    if (labeledUltrasoundFile != null)
                                    {
                                        var labeledInfo = new LabeledUltrasoundFileInfo();
                                        await GetLabeledUltrasoundFileInfo(databaseService, labeledUltrasoundFile, labeledInfo, false);
                                        labeledUltrasoundFileInfo.RelabeledInfos ??= new List<LabeledUltrasoundFileInfo>();
                                        labeledUltrasoundFileInfo.RelabeledInfos.Add(labeledInfo);
                                    }
                                }
                            }
                            labeledUltrasoundFileInfos.Add(labeledUltrasoundFileInfo);
                        }
                    }
                    return labeledUltrasoundFileInfos;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        private async Task GetLabeledUltrasoundFileInfo(IDatabaseService databaseService, LabeledUltrasoundFile labeledImage, LabeledUltrasoundFileInfo labeledUltrasoundFileInfo, bool hasImageData)
        {
            var archivedImageDataManager = databaseService.GetManager<IArchivedImageDataManager>();
            var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();
            var reviewedResultDataManager = databaseService.GetManager<IReviewedResultDataManager>();

            var labelerName = labeledImage.Labeler.Name;
            labeledUltrasoundFileInfo.Labeler = labelerName;
            labeledUltrasoundFileInfo.LabeledUltrasoundFile = labeledImage;

            foreach (var item in labeledImage.FileResultInfos)
            {
                var result = new PreviewFrameModel
                {
                    Index = item.Index,
                    FrameStatus = item.FrameStatus,
                    IsKeyFrame = item.IsKeyFrame,
                    Type = item.Type,
                    RegionCount = item.RegionCount,
                    FirstValidLabeledTime = item.FirstValidLabeledTime,
                };
                //LabeledResult
                if (item.LabeledResultId > 0)
                {
                    result.LabeledResult = await labeledResultDataManager.GetLabeledResultAsync(item.LabeledResultId);
                    result.LabelConclusions = GetLabelConclusions(result.LabeledResult);
                }

                //ReviewedResult
                result.ReviewerInfos = await GetReviewerInfos(reviewedResultDataManager, item.ReviewedInfos);
                labeledUltrasoundFileInfo.FileResultInfos.Add(result);
            }

            if (hasImageData)
            {
                // Preview LabeledResult
                var hasLabeledResult = labeledUltrasoundFileInfo.FileResultInfos.FirstOrDefault(x => x.Type > LabelType.None);
                if (hasLabeledResult == null)
                {
                    hasLabeledResult = labeledUltrasoundFileInfo.FileResultInfos.FirstOrDefault();
                }
                if (hasLabeledResult != null)
                {
                    labeledUltrasoundFileInfo.LabeledResult = hasLabeledResult.LabeledResult;
                    labeledUltrasoundFileInfo.LabelConclusions = hasLabeledResult.LabelConclusions;
                }

                //ImageData
                var archivedImage = await archivedImageDataManager.GetArchivedImageAsync(labeledImage.ArchivedImageId);
                if (labeledImage.IsVideo)
                {
                    labeledUltrasoundFileInfo.ImageData = SkiaSharpHelper.GetLabeledImageData(archivedImage.ImageData, archivedImage.Width, archivedImage.Height, labeledUltrasoundFileInfo.LabeledResult.Rois);
                }
                else
                {
                    labeledUltrasoundFileInfo.ImageData = archivedImage.ImageData;
                }
                labeledUltrasoundFileInfo.ArchivedImage = new EntityBase { Id = archivedImage.Id, Name = archivedImage.OriginalName };
            }
        }

        /// <summary>
        /// 获取原始视频字节数组
        /// </summary>
        /// <param name="archivedImage">原始图像</param>
        /// <returns></returns>
        private async Task<byte[]> GetArchivedVideoData(ArchivedImage archivedImage)
        {
            var videoPath = Path.Combine(CommonConfigManager.VideoTranscodingFolder, archivedImage.Id.ToString(), archivedImage.OriginalName);
            if (File.Exists(videoPath))
            {
                return await File.ReadAllBytesAsync(videoPath);
            }
            return null;
        }

        /// <summary>
        /// 获取标注结论
        /// </summary>
        /// <param name="labeledResult"></param>
        /// <returns></returns>
        private static List<LabelConclusion> GetLabelConclusions(LabeledResult labeledResult)
        {
            var conclusions = new List<LabelConclusion>();
            if (labeledResult != null)
            {
                var num = 0;
                if (labeledResult.ImageResults.Any(x => x.Index == 0))
                {
                    num = 1;
                }
                foreach (var imageResult in labeledResult.ImageResults)
                {
                    conclusions.Add(new LabelConclusion
                    {
                        Title = $"[图像标签-{imageResult.Index + num}]",
                        Unit = imageResult.Unit.Title,
                        Content = imageResult.Conclusion.Title
                    });
                }
                num = 0;
                if (labeledResult.Rois.Any(x => x.Index == 0))
                {
                    num = 1;
                }
                foreach (var roi in labeledResult.Rois)
                {
                    if (roi.Conclusion != null)
                    {
                        conclusions.Add(new LabelConclusion
                        {
                            Title = $"[ROI-{roi.Index + num}]",
                            Unit = roi.Unit.Title,
                            Content = roi.Conclusion.Title
                        });
                    }
                }
            }
            return conclusions;
        }

        /// <summary>
        /// 获取审核结论
        /// </summary>
        /// <param name="reviewedResultDataManager"></param>
        /// <param name="reviewedInfos"></param>
        /// <returns></returns>
        private static async Task<List<ReviewerInfo>> GetReviewerInfos(IReviewedResultDataManager reviewedResultDataManager, List<ReviewedInfo> reviewedInfos)
        {
            List<ReviewerInfo> reviewerInfos = null;
            if (reviewedInfos != null)
            {
                reviewerInfos = new List<ReviewerInfo>();
                foreach (var item in reviewedInfos)
                {
                    var num = 0;
                    var reviewedResult = await reviewedResultDataManager.GetReviewedResultAsync(item.ReviewedResultId);
                    var conclusionInfos = reviewedResult.ConclusionInfos;
                    if (conclusionInfos.Any(x => x.Index == 0))
                    {
                        num = 1;
                    }
                    var results = new List<SingleReviewedResult>();
                    var isPassed = true;
                    foreach (var sub in conclusionInfos)
                    {
                        if (sub.IsImageLabelError || sub.IsRoiError)
                        {
                            isPassed = false;
                            var index = sub.Index + num;
                            var str = sub.IsRoi ? "ROI" : "图像标签";
                            var strIsImage = sub.IsImageLabelError ? "标签错误" : "";
                            var strIsRoi = sub.IsRoiError ? "ROI错误" : "";
                            results.Add(new SingleReviewedResult
                            {
                                Title = $"[{str}-{index}]",
                                ReviewResult = $"{strIsImage} {strIsRoi}",
                                ReviewComment = sub.ReviewComment,
                            });
                        }
                    }
                    var reviewerInfo = new ReviewerInfo
                    {
                        Reviewer = item.Reviewer,
                        IsPassed = isPassed,
                        Results = results,
                    };
                    reviewerInfos.Add(reviewerInfo);
                }
            }

            return reviewerInfos;
        }

        /// <summary>
        /// Get all the labeled files for one source image by all labelers.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <param name="pageIndex">The page index</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <returns>found ultrasound images</returns>
        public async Task<int> GetLabeledUltrasoundFilesCountByUltrasoundFileIdAsync(long sessionId, long ultrasoundFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var count = await labeledUltrasoundFileDataManager.GetLabeledFilesCountByUltrasoundFileIdAsync(ultrasoundFileId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled files count of UltrasoundFile {ultrasoundFileId} from system");
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all the labeled files for one source image by all labelers.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The combination tag id of images</param>
        /// <returns>found ultrasound images count</returns>
        public async Task<int> GetValidAdoptableLabeledUltrasoundFilesCountOfImageCategoryIdAsync(long sessionId, long imageCategoryId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var count = await labeledUltrasoundFileDataManager.GetValidAdoptableLabeledUltrasoundFileCountByImageCategoryIdAsync(imageCategoryId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get valid adoptable labeled files count of combination tag {imageCategoryId} from system");
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the labeled result by id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<LabeledResult> GetLabeledResultAsync(long sessionId, long id)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled result by id {id}.");
                    return await labeledResultDataManager.GetLabeledResultAsync(id);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        private async Task DeleteLabelCaseImagesByLabeledUltrasoundFileIdAsync(long imageId, string sessionName)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
            var labeledCaseImage = await caseDataManager.GetAssignedLabelCaseFileByLabeledUltrasoundFileIdAsync(imageId);
            if (labeledCaseImage != null)
            {
                await caseDataManager.DeleteAssignedLabelCaseFileAsync(labeledCaseImage.Id);
                await SystemLogger.WriteLogAsync($"Admin - {sessionName} delete labeled case image {labeledCaseImage}.");

                var labelCaseImages = await caseDataManager.GetAssignedLabelCaseFilesByCaseIdAsync(labeledCaseImage.AssignedLabelCaseId);
                for (var i = 0; i < labelCaseImages.Count; i++)
                {
                    labelCaseImages[i].Index = i;
                    await caseDataManager.UpdateAssignedLabelCaseFileAsync(labelCaseImages[i]);
                }
            }
        }

        private async Task DeleteLabelCaseImagesByUltrasoundFileIdAsync(long imageId, string sessionName)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
            var labeledCaseImage = await caseDataManager.GetLastAssignedLabelCaseFileByUltrasoundFileIdAsync(imageId);
            if (labeledCaseImage != null)
            {
                await caseDataManager.DeleteAssignedLabelCaseFileAsync(labeledCaseImage.Id);
                await SystemLogger.WriteLogAsync($"Admin - {sessionName} delete labeled case image {labeledCaseImage}.");

                var labelCaseImages = await caseDataManager.GetAssignedLabelCaseFilesByCaseIdAsync(labeledCaseImage.AssignedLabelCaseId);
                for (var i = 0; i < labelCaseImages.Count; i++)
                {
                    labelCaseImages[i].Index = i;
                    await caseDataManager.UpdateAssignedLabelCaseFileAsync(labelCaseImages[i]);
                }
            }
        }

        /// <summary>
        /// Delete ultrasound image by ultrasound image id
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="ultrasoundFileId">The id of the image</param>
        /// <returns>Void</returns>
        public async Task DeleteUltrasoundFileAsync(long sessionId, long ultrasoundFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(ultrasoundFileId);
                    if (ultrasoundFile != null)
                    {
                        await ultrasoundFileDataManager.DeleteUltrasoundFileAsync(ultrasoundFileId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted ultrasound image {ultrasoundFileId}.");
                        if (ultrasoundFile.Labeled)
                        {
                            var labeledImages = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesByUltrasoundFileIdAndProjectionAsync(ultrasoundFileId);
                            if (labeledImages != null)
                            {
                                foreach (var labeledImage in labeledImages)
                                {
                                    await labeledUltrasoundFileDataManager.DeleteLabeledUltrasoundFileAsync(labeledImage.Id);
                                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted labeled ultrasound image {labeledImage}.");
                                    await DeleteLabelCaseImagesByLabeledUltrasoundFileIdAsync(labeledImage.Id, session.Name);
                                }
                            }
                        }
                        else
                        {
                            await DeleteLabelCaseImagesByUltrasoundFileIdAsync(ultrasoundFile.Id, session.Name);
                        }
                    }
                    else
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Delete labeled ultrasound image by ultrasound image id
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="labeledUltrasoundFileId">The id of the image</param>
        /// <returns>Void</returns>
        public async Task DeleteLabeledUltrasoundFileAsync(long sessionId, long labeledUltrasoundFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseeDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(labeledUltrasoundFileId);
                    if (labeledUltrasoundFile == null)
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }

                    await labeledUltrasoundFileDataManager.DeleteLabeledUltrasoundFileAsync(labeledUltrasoundFile.Id);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted labeled ultrasound image {labeledUltrasoundFileId}.");

                    var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(labeledUltrasoundFile.UltrasoundFileId);
                    if (ultrasoundFile != null)
                    {
                        var labeledCaseImage = await caseeDataManager.GetAssignedLabelCaseFileByLabeledUltrasoundFileIdAsync(labeledUltrasoundFile.Id);
                        if (labeledCaseImage != null)
                        {
                            labeledCaseImage.IsLabeled = false;
                            labeledCaseImage.LabeledUltrasoundFileIds.Remove(labeledUltrasoundFile.Id);
                            await caseeDataManager.UpdateAssignedLabelCaseFileAsync(labeledCaseImage);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} update labeled case image {labeledCaseImage.Id}.");
                        }

                        var labeledImageCount = await labeledUltrasoundFileDataManager.GetLabeledFilesCountByUltrasoundFileIdAsync(ultrasoundFile.Id);
                        if (labeledImageCount == 0)
                        {
                            ultrasoundFile.Labeled = false;
                            ultrasoundFile.LabeledTypes = new LabelType[0];
                            await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} update ultrasound image {ultrasoundFile.Id} to unlabeled.");
                        }
                    }
                    else
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Delete all labeled ultrasound image for one ultrasound image by the ultrasound image id.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="ultrasoundFileId">The id of the ultrasound image</param>
        /// <returns>Void</returns>
        public async Task DeleteAllLabeledUltrasoundFilesByUltrasoundFileIdAsync(long sessionId, long ultrasoundFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseeDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(ultrasoundFileId);
                    if (ultrasoundFile == null)
                    {
                        throw new InvalidOperationException("UltrasoundFileNotExist");
                    }

                    var labeledImages = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesByUltrasoundFileIdAndProjectionAsync(ultrasoundFileId);
                    if (labeledImages != null)
                    {
                        foreach (var labeledImage in labeledImages)
                        {
                            await labeledUltrasoundFileDataManager.DeleteLabeledUltrasoundFileAsync(labeledImage.Id);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted labeled ultrasound image {labeledImage}.");

                            var labeledCaseImage = await caseeDataManager.GetAssignedLabelCaseFileByLabeledUltrasoundFileIdAsync(labeledImage.Id);
                            if (labeledCaseImage != null)
                            {
                                labeledCaseImage.IsLabeled = false;
                                labeledCaseImage.UltrasoundFileId = ultrasoundFile.Id;
                                await caseeDataManager.UpdateAssignedLabelCaseFileAsync(labeledCaseImage);
                                await SystemLogger.WriteLogAsync($"Admin - {session.Name} update labeled case image {labeledCaseImage.Id}.");
                            }
                        }
                    }
                    var labeledImageCount = await labeledUltrasoundFileDataManager.GetLabeledFilesCountByUltrasoundFileIdAsync(ultrasoundFileId);
                    if (labeledImageCount == 0)
                    {
                        ultrasoundFile.Labeled = false;
                        ultrasoundFile.LabeledTypes = new LabelType[0];
                        await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} update ultrasound image {ultrasoundFile.Id} to unlabeled.");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Assign label case to labelers again.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="sameBatchLabelCaseId">The same batch label case id.</param>
        /// <param name="labelers">The labelers.</param>
        /// <returns></returns>
        public async Task<long> AssignLabelCaseAgainAsync(long sessionId, long sameBatchLabelCaseId, List<EntityBase> labelers)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var operationId = IdCreator.CreateId();
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var assignedLabelCaseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                var goldStandardFileDataManager = databaseService.GetManager<IGoldStandardFileDataManager>();
                var goldStandardAssignedFileDataManager = databaseService.GetManager<IGoldStandardAssignedFileDataManager>();
                var selfCheckAssignedFileDataManager = databaseService.GetManager<ISelfCheckAssignedFileDataManager>();
                var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(sameBatchLabelCaseId);
                var firstAssignedLabelCase = await assignedLabelCaseDataManager.GetAssignedLabelCaseBySameBatchLabelCaseIdAsync(sameBatchLabelCaseId);
                var sourceAssignedLabelCaseGroups = await assignedLabelCaseDataManager.GetAssignedLabelCaseGroupsByCaseIdAsync(firstAssignedLabelCase.Id);
                var imageCategoryId = firstAssignedLabelCase.ImageCategoryId;
                var assignIndex = 0;
                var assignTotal = sameBatchLabelCase.AssignCount.File * labelers.Count;
                var firstLabelerInfo = sameBatchLabelCase.Labelers.FirstOrDefault(x => x.AssignedLabelCaseId == firstAssignedLabelCase.Id);

                var assignLabelCaseGroupModels = new List<AssignLabelCaseGroupModel>();
                foreach (var group in sourceAssignedLabelCaseGroups)
                {
                    var assignLabelCaseGroupModel = new AssignLabelCaseGroupModel
                    {
                        Group = group,
                    };
                    var assignedLabelCaseFiles = await assignedLabelCaseDataManager.GetAssignedLabelCaseFilesByGroupIdAsync(group.Id);
                    if (assignedLabelCaseFiles != null)
                    {
                        assignLabelCaseGroupModel.Files = assignedLabelCaseFiles;
                    }
                    assignLabelCaseGroupModels.Add(assignLabelCaseGroupModel);
                }

                foreach (var labeler in labelers)
                {
                    #region Create AssignedLabelCase

                    long institutionId = 0;
                    var account = await accountDataManager.GetAccountAsync(labeler.Id);
                    if (account != null)
                    {
                        institutionId = account.InstitutionId;
                    }
                    var assignedCaseCount = (int)await assignedLabelCaseDataManager.GetAssignedLabelCaseCountAsync(labeler.Id);
                    var assignedLabelCase = new AssignedLabelCase
                    {
                        Name = firstAssignedLabelCase.Name,
                        Labeler = labeler,
                        SameBatchLabelCaseId = firstAssignedLabelCase.SameBatchLabelCaseId,
                        OrganizationId = firstAssignedLabelCase.OrganizationId,
                        ImageCategoryId = imageCategoryId,
                        ImageBatchId = firstAssignedLabelCase.ImageBatchId,
                        ImageCaseId = firstAssignedLabelCase.ImageCaseId,
                        LabelPackageContentId = firstAssignedLabelCase.LabelPackageContentId,
                        InstitutionId = institutionId,
                        Mode = firstAssignedLabelCase.Mode,
                        CaseIndex = assignedCaseCount,
                        DevelopConfirmInfo = firstAssignedLabelCase.DevelopConfirmInfo,
                    };
                    await assignedLabelCaseDataManager.CreateAssignedLabelCaseAsync(assignedLabelCase);

                    #endregion Create AssignedLabelCase

                    #region Create AssignedLabelCaseFile

                    #region Add eachCount

                    var count = new QuantityBase();
                    foreach (var assignLabelCaseGroupModel in assignLabelCaseGroupModels)
                    {
                        var sourceGroup = assignLabelCaseGroupModel.Group;
                        var assignedLabelCaseGroup = new AssignedLabelCaseGroup
                        {
                            ImageCategoryId = imageCategoryId,
                            AssignedLabelCaseId = assignedLabelCase.Id,
                            UltrasoundGroupId = sourceGroup.UltrasoundGroupId,
                            Index = count.Group,
                            DevelopConfirmInfo = sourceGroup.DevelopConfirmInfo,
                        };
                        await assignedLabelCaseDataManager.CreateAssignedLabelCaseGroupAsync(assignedLabelCaseGroup);

                        foreach (var sourceFile in assignLabelCaseGroupModel.Files)
                        {
                            var assignedLabelCaseFile = new AssignedLabelCaseFile()
                            {
                                ImageCategoryId = imageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                AssignedLabelCaseGroupId = assignedLabelCaseGroup.Id,
                                UltrasoundFileId = sourceFile.UltrasoundFileId,
                                Index = sourceFile.Index,
                                IsVideo = sourceFile.IsVideo,
                                KeyFrameIndexList = sourceFile.KeyFrameIndexList,
                                VideoItem = sourceFile.VideoItem,
                                DevelopConfirmInfo = sourceFile.DevelopConfirmInfo
                            };
                            await assignedLabelCaseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);

                            count.File++;
                            assignIndex++;
                            var progress = (int)((double)assignIndex / assignTotal * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }

                        count.Group++;
                    }

                    #endregion Add eachCount

                    #region Add goldStandardFilesCount

                    var actualAddedGoldStandardCount = 0;
                    var ultrasoundFileIds = new List<long>();
                    if (firstLabelerInfo.AddGoldStandardCount.Group > 0)
                    {
                        var goldStandardAssignedFiles = await goldStandardAssignedFileDataManager.GetGoldStandardAssignedFilesAsync(imageCategoryId, labeler.Id);
                        if (goldStandardAssignedFiles.Any())
                        {
                            ultrasoundFileIds = goldStandardAssignedFiles.Select(x => x.UltrasoundFileId).ToList();
                        }
                        var goldStandardFiles = await goldStandardFileDataManager.GetGoldStandardFilesExcludeUltrasoundFileIdsAsync(imageCategoryId, ultrasoundFileIds, firstLabelerInfo.AddGoldStandardCount.Group);
                        foreach (var goldStandardFile in goldStandardFiles)
                        {
                            var ultrasoundFileId = goldStandardFile.UltrasoundFileId;
                            var assignedLabelCaseFile = new AssignedLabelCaseFile()
                            {
                                ImageCategoryId = imageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                UltrasoundFileId = ultrasoundFileId,
                                Index = count.File,
                                IsLabeled = false,
                                MixedFileType = MixedFileType.GoldStandard,
                                IsVideo = goldStandardFile.IsVideo,
                            };
                            await assignedLabelCaseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                            count.File++;
                            assignIndex++;

                            #region Add GoldStandardAssignedFile

                            var goldStandardAssignedFile = await goldStandardAssignedFileDataManager.GetGoldStandardAssignedFileByUltrasoundFileIdAsync(ultrasoundFileId);
                            if (goldStandardAssignedFile == null)
                            {
                                goldStandardAssignedFile = new GoldStandardAssignedFile
                                {
                                    ImageCategoryId = imageCategoryId,
                                    UltrasoundFileId = ultrasoundFileId,
                                };
                                var labelerAssignedInfo = new LabelerAssignedInfo
                                {
                                    Labeler = new EntityBase { Id = labeler.Id, Name = labeler.Name }
                                };
                                labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                goldStandardAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                await goldStandardAssignedFileDataManager.CreateGoldStandardAssignedFileAsync(goldStandardAssignedFile);
                                actualAddedGoldStandardCount++;
                            }
                            else
                            {
                                var isUpdate = false;
                                var labelerAssignedInfo = goldStandardAssignedFile.LabelerAssignedInfos.FirstOrDefault(x => x.Labeler.Id == labeler.Id);
                                if (labelerAssignedInfo == null)
                                {
                                    labelerAssignedInfo = new LabelerAssignedInfo
                                    {
                                        Labeler = new EntityBase { Id = labeler.Id, Name = labeler.Name }
                                    };
                                    labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                    goldStandardAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                    isUpdate = true;
                                }
                                else if (!labelerAssignedInfo.FileInfos.Exists(x => x.AssignedLabelCaseFileId == assignedLabelCaseFile.Id))
                                {
                                    labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                    goldStandardAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                    isUpdate = true;
                                }
                                if (isUpdate)
                                {
                                    await goldStandardAssignedFileDataManager.UpdateGoldStandardAssignedFileAsync(goldStandardAssignedFile);
                                    actualAddedGoldStandardCount++;
                                }
                            }
                            #endregion Add GoldStandardAssignedFile

                            var progress = (int)((double)assignIndex / assignTotal * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }
                    }

                    #endregion Add goldStandardFilesCount

                    #region Add selfCheckFilesCount

                    var actualAddedSelfCheckCount = 0;
                    if (firstLabelerInfo.AddSelfCheckCount.Group > 0)
                    {
                        var selfCheckAssignedFiles = await selfCheckAssignedFileDataManager.GetSelfCheckAssignedFilesAsync(imageCategoryId, labeler.Id);
                        if (selfCheckAssignedFiles.Any())
                        {
                            ultrasoundFileIds.AddRange(selfCheckAssignedFiles.Select(x => x.UltrasoundFileId));
                        }
                        var selfCheckFiles = await assignedLabelCaseDataManager.GetAssignedLabelCaseFilesExcludeUltrasoundFileIdsAsync(imageCategoryId, ultrasoundFileIds, firstLabelerInfo.AddSelfCheckCount.Group);
                        foreach (var selfCheckFile in selfCheckFiles)
                        {
                            var ultrasoundFileId = selfCheckFile.UltrasoundFileId;
                            var assignedLabelCaseFile = new AssignedLabelCaseFile()
                            {
                                ImageCategoryId = imageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                UltrasoundFileId = ultrasoundFileId,
                                Index = count.File,
                                IsLabeled = false,
                                MixedFileType = MixedFileType.SelfCheck,
                                IsVideo = selfCheckFile.IsVideo,
                            };
                            await assignedLabelCaseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                            count.File++;
                            assignIndex++;

                            #region Add SelfCheckAssignedFile

                            var selfCheckAssignedFile = await selfCheckAssignedFileDataManager.GetSelfCheckAssignedFileByUltrasoundFileIdAsync(ultrasoundFileId);
                            if (selfCheckAssignedFile == null)
                            {
                                selfCheckAssignedFile = new SelfCheckAssignedFile
                                {
                                    ImageCategoryId = imageCategoryId,
                                    UltrasoundFileId = ultrasoundFileId,
                                };
                                var labelerAssignedInfo = new LabelerAssignedInfo
                                {
                                    Labeler = new EntityBase { Id = labeler.Id, Name = labeler.Name }
                                };
                                labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                selfCheckAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                await selfCheckAssignedFileDataManager.CreateSelfCheckAssignedFileAsync(selfCheckAssignedFile);
                                actualAddedSelfCheckCount++;
                            }
                            else
                            {
                                var isUpdate = false;
                                var labelerAssignedInfo = selfCheckAssignedFile.LabelerAssignedInfos.FirstOrDefault(x => x.Labeler.Id == labeler.Id);
                                if (labelerAssignedInfo == null)
                                {
                                    labelerAssignedInfo = new LabelerAssignedInfo
                                    {
                                        Labeler = new EntityBase { Id = labeler.Id, Name = labeler.Name }
                                    };
                                    labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                    selfCheckAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                    isUpdate = true;
                                }
                                else if (!labelerAssignedInfo.FileInfos.Exists(x => x.AssignedLabelCaseFileId == assignedLabelCaseFile.Id))
                                {
                                    labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                    selfCheckAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                    isUpdate = true;
                                }
                                if (isUpdate)
                                {
                                    await selfCheckAssignedFileDataManager.UpdateSelfCheckAssignedFileAsync(selfCheckAssignedFile);
                                    actualAddedSelfCheckCount++;
                                }
                            }
                            #endregion Add SelfCheckAssignedFile

                            var progress = (int)((double)assignIndex / assignTotal * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }
                    }

                    #endregion Add selfCheckFilesCount

                    #endregion Create AssignedLabelCaseFile

                    #region Update AssignedLabelCase

                    assignedLabelCase.Count = count;
                    await assignedLabelCaseDataManager.UpdateAssignCaseAsync(assignedLabelCase);

                    #endregion Update AssignedLabelCase

                    #region Update SameBatchLabelCase

                    sameBatchLabelCase.Labelers.Add(new SameBatchLabelerInfo
                    {
                        Id = labeler.Id,
                        Name = labeler.Name,
                        State = ReviewState.Assigned,
                        AssignedLabelCaseId = assignedLabelCase.Id,
                        InstitutionId = institutionId,
                        AssignCount = firstLabelerInfo.AssignCount,
                        AddGoldStandardCount = firstLabelerInfo.AddGoldStandardCount,
                        AddSelfCheckCount = firstLabelerInfo.AddSelfCheckCount,
                        AssignRestCount = firstLabelerInfo.AssignRestCount,
                    });

                    #endregion Update SameBatchLabelCase

                    #region Create LabelerGroup

                    var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(labeler.Id, institutionId, firstAssignedLabelCase.ImageCategoryId);
                    if (labelerGroup == null)
                    {
                        labelerGroup = new LabelerGroup
                        {
                            Labeler = new EntityBase { Id = labeler.Id, Name = labeler.Name },
                            ImageCategoryId = firstAssignedLabelCase.ImageCategoryId,
                            OrganizationId = firstAssignedLabelCase.OrganizationId,
                            LabelCaseQuantityItem = new AssignedCaseQuantityItem
                            {
                                Total = firstAssignedLabelCase.Count.File,
                                Remaining = firstAssignedLabelCase.Count.File,
                            },
                            GoldStandardAssignedCount = actualAddedGoldStandardCount,
                            SelfCheckAssignedCount = actualAddedSelfCheckCount,
                        };
                        await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                    }
                    else
                    {
                        labelerGroup.LabelCaseQuantityItem.Total += firstAssignedLabelCase.Count.File;
                        labelerGroup.LabelCaseQuantityItem.Remaining += firstAssignedLabelCase.Count.File;
                        labelerGroup.GoldStandardAssignedCount += actualAddedGoldStandardCount;
                        labelerGroup.SelfCheckAssignedCount += actualAddedSelfCheckCount;
                        await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                    }
                    #endregion Create LabelerGroup
                }

                #region Update SameBatchLabelCase

                sameBatchLabelCase.State = SameBatchLabelCaseState.LabelerAssigned;
                await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);

                #endregion Update SameBatchLabelCase

                #region Update ImageCase Labelers

                var users = sameBatchLabelCase.Labelers.Select(x => new EntityBase { Id = x.Id, Name = x.Name }).ToList();
                await imageCategoryDataManager.UpdateImageCategoryLabelersAsync(sameBatchLabelCase.ImageCaseId, users);

                #endregion Update ImageCase Labelers

                OperationManager.SetProgress(operationId, 100);
                return operationId;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update same batch label case
        /// </summary>
        /// <param name="id">The id of SameBatchLabelCase.</param>
        /// <param name="isHideLabelerName">Whether to hide Labeler Name.</param>
        /// <returns></returns>
        public async Task UpdateSameBatchLabelCaseAsync(long sessionId, long id, bool isHideLabelerName, bool isHideReviewerName)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(id);
                if (sameBatchLabelCase == null)
                {
                    throw new InvalidOperationException("SameBatchLabelCaseNotExist");
                }

                sameBatchLabelCase.IsHideLabelerName = isHideLabelerName;
                sameBatchLabelCase.IsHideReviewerName = isHideReviewerName;
                await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Set label case to unadoptable
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="sameBatchLabelCase">The SameBatchLabelCase.</param>
        /// <returns></returns>
        public async Task SetSameBatchLabelCaseToUnAdoptableAsync(long sessionId, SameBatchLabelCase sameBatchLabelCase)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var labeledUltrasoundImageDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                var assignedLabelCaseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                foreach (var labeler in sameBatchLabelCase.Labelers)
                {
                    var labeledUltrasoundImageIds = await assignedLabelCaseDataManager.GetLabeledUltrasoundFileIdsForAssignedLabelCaseFilesAsync(labeler.AssignedLabelCaseId);
                    foreach (var id in labeledUltrasoundImageIds)
                    {
                        await labeledUltrasoundImageDataManager.UpdateLabeledUltrasoundFileIsAdoptableAsync(id, false);
                    }
                }

                sameBatchLabelCase.State = SameBatchLabelCaseState.Abandonment;
                await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
                await SystemLogger.WriteLogAsync($"Admin - {session.Name} set sameBatchLabelCase {sameBatchLabelCase.Name} to unAdoptable.");
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Clear labeled files
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="sameBatchLabelCaseId">The same batch label case id.</param>
        /// <returns></returns>
        public async Task ClearLabeledFilesAsync(long sessionId, long sameBatchLabelCaseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var goldStandardFileDataManager = databaseService.GetManager<IGoldStandardFileDataManager>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var labelCaseStatisticDataManager = databaseService.GetManager<ILabelCaseStatisticDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(sameBatchLabelCaseId);
                    if (sameBatchLabelCase == null)
                    {
                        throw new InvalidOperationException("SameBatchLabelCaseNotExist");
                    }
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(sameBatchLabelCase.ImageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(sameBatchLabelCase.ImageBatchId);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(sameBatchLabelCase.ImageCaseId);
                    if (imageCase == null)
                    {
                        throw new InvalidOperationException("ImageCaseNotExist");
                    }

                    #region Update SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    foreach (var labelerInfo in sameBatchLabelCase.Labelers)
                    {
                        var assignedLabelCase = await caseDataManager.GetAssignedLabelCaseAsync(labelerInfo.AssignedLabelCaseId);
                        var assignedLabelCaseFiles = await caseDataManager.GetAssignedLabelCaseFilesByHasSeenAsync(labelerInfo.AssignedLabelCaseId, true);
                        foreach (var assignedLabelCaseFile in assignedLabelCaseFiles)
                        {
                            long goldStandardLabeledFileId = 0;

                            #region Dalete LabeledUltrasoundFile & LabeledResult

                            foreach (var item in assignedLabelCaseFile.LabeledUltrasoundFileIds)
                            {
                                var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(item.Key);
                                if (labeledUltrasoundFile != null)
                                {
                                    foreach (var info in labeledUltrasoundFile.FileResultInfos)
                                    {
                                        if (info.LabeledResultId > 0)
                                        {
                                            await labeledResultDataManager.DeleteLabeledResultAsync(info.LabeledResultId);
                                        }
                                    }
                                    await labeledUltrasoundFileDataManager.DeleteLabeledUltrasoundFileAsync(labeledUltrasoundFile.Id);

                                    if (labeledUltrasoundFile.IsGoldStandard)
                                    {
                                        goldStandardLabeledFileId = labeledUltrasoundFile.Id;
                                    }
                                }
                            }
                            #endregion

                            #region Delete GoldStandard

                            if (goldStandardLabeledFileId > 0)
                            {
                                var goldStandardFile = await goldStandardFileDataManager.GetGoldStandardFileByUltrasoundFileIdAsync(assignedLabelCaseFile.UltrasoundFileId);
                                if (goldStandardFile != null)
                                {
                                    await goldStandardFileDataManager.DeleteGoldStandardFileAsync(goldStandardFile.Id);
                                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} delete GoldStandardFile of UltrasoundFile {goldStandardFile.UltrasoundFileId}.");
                                }
                            }

                            #endregion

                            #region Update UltrasoundFile

                            var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(assignedLabelCaseFile.UltrasoundFileId);
                            var labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelAsync(CategoryLevel.Batch, assignedLabelCase.ImageBatchId, ultrasoundFile.Id);
                            if (labeledUltrasoundFiles == null || labeledUltrasoundFiles.Count == 0)
                            {
                                ultrasoundFile.Labeled = false;
                                ultrasoundFile.HasSeen = false;
                                ultrasoundFile.IsSkipped = false;
                                ultrasoundFile.IsAdoptable = false;
                                ultrasoundFile.GoldStandardLabeledFileId = -1;
                                ultrasoundFile.LabeledTypes = new LabelType[0];
                                for (int i = 0; i < ultrasoundFile.ImageCaseInfos.Count; i++)
                                {
                                    var info = ultrasoundFile.ImageCaseInfos[i];
                                    info.IsLabeled = false;
                                    info.HasSeen = false;
                                    info.IsSkipped = false;
                                }
                            }
                            else
                            {
                                labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelAsync(CategoryLevel.SameBatchLabelCase, assignedLabelCase.ImageCaseId, ultrasoundFile.Id);
                                for (int i = 0; i < ultrasoundFile.ImageCaseInfos.Count; i++)
                                {
                                    var info = ultrasoundFile.ImageCaseInfos[i];
                                    info.IsLabeled = labeledUltrasoundFiles.Any(x => x.ImageCaseId == info.Id && !x.IsSkipped);
                                    info.IsSkipped = labeledUltrasoundFiles.All(x => x.ImageCaseId == info.Id && x.IsSkipped);
                                    info.HasSeen = labeledUltrasoundFiles.Any(x => x.ImageCaseId == info.Id);
                                }
                                ultrasoundFile.Labeled = labeledUltrasoundFiles.Any(x => !x.IsSkipped);
                                ultrasoundFile.IsSkipped = labeledUltrasoundFiles.All(x => x.IsSkipped);
                                ultrasoundFile.HasSeen = true;
                                ultrasoundFile.IsAdoptable = labeledUltrasoundFiles.Any(x => x.IsAdoptable);
                            }
                            await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);

                            #endregion

                            #region Update AssignedLabelCaseFile

                            assignedLabelCaseFile.IsLabeled = false;
                            assignedLabelCaseFile.HasSeen = false;
                            assignedLabelCaseFile.IsSkipped = false;
                            assignedLabelCaseFile.FirstSubmissionTime = new DateTime();
                            assignedLabelCaseFile.LabeledUltrasoundFileIds = new Dictionary<long, DateTime>();
                            await caseDataManager.UpdateAssignedLabelCaseFileAsync(assignedLabelCaseFile);

                            #endregion
                        }

                        #region Update LabelerGroup

                        var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(labelerInfo.Id, labelerInfo.InstitutionId, imageCategory.Id);
                        if (labelerGroup != null)
                        {
                            labelerGroup.LabelCaseQuantityItem.Submitted -= assignedLabelCase.SeenCount.File;
                            labelerGroup.LabelCaseQuantityItem.Valid -= assignedLabelCase.LabeledCount.File;
                            labelerGroup.LabelCaseQuantityItem.Remaining += assignedLabelCase.SeenCount.File;
                            await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                        }

                        #endregion

                        #region Update LabelerGroupItems

                        var labelerGroupItems = await labelerGroupDataManager.GetLabelerGroupItemsAsync(labelerGroup.Id, labelerInfo.AssignedLabelCaseId, 0);
                        foreach (var item in labelerGroupItems)
                        {
                            item.LabelSubmittedCount = 0;
                            item.LabelValidCount = 0;
                            await labelerGroupDataManager.UpdateLabelerGroupItemAsync(item);
                        }

                        #endregion

                        #region Delete LabelCaseStatistic

                        if (assignedLabelCase.LabelCaseStatisticsId > 0)
                        {
                            await labelCaseStatisticDataManager.DeleteLabelCaseStatisticAsync(assignedLabelCase.LabelCaseStatisticsId);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} delete LabelCaseStatistic Id {assignedLabelCase.LabelCaseStatisticsId}.");
                        }

                        #endregion

                        #region Update Labeler ScoreInfos

                        var labeler = await accountDataManager.GetAccountAsync(labelerInfo.Id);
                        var scoreInfos = labeler.LabelerAuthorityInfo.ScoreInfos;
                        var findScoreInfo = scoreInfos.FirstOrDefault(x => x.ImageCategory.Id == imageCategory.Id);
                        if (findScoreInfo != null)
                        {
                            var findDetail = findScoreInfo.LabelCaseDetails.FirstOrDefault(x => x.AssignedLabelCaseId == assignedLabelCase.Id);
                            if (findDetail != null)
                            {
                                findDetail.GoldStandard.ConsistentCount = 0;
                                findDetail.GoldStandard.ConsistentRate = 0;
                                findDetail.SelfCheck.ConsistentCount = 0;
                                findDetail.SelfCheck.ConsistentRate = 0;
                            }
                            labeler.LabelerAuthorityInfo.LastAssignedLabelCaseGroupId = 0;
                            labeler.LabelerAuthorityInfo.LastAssignedLabelCaseFileId = 0;
                            await accountDataManager.UpdateAccountLabelerAuthorityInfoAsync(labeler.Id, labeler.LabelerAuthorityInfo);
                        }

                        #endregion Update Labeler ScoreInfos

                        #region Update AssignedLabelCase

                        assignedLabelCase.LabeledCount = new QuantityBase();
                        assignedLabelCase.SeenCount = new QuantityBase();
                        assignedLabelCase.SkippedCount = new QuantityBase();
                        assignedLabelCase.LabelCaseStatisticsId = -1;
                        await caseDataManager.UpdateAssignCaseAsync(assignedLabelCase);

                        #endregion

                        #region Update SameBatchLabelCase Labelers

                        labelerInfo.State = ReviewState.Assigned;
                        labelerInfo.LabeledCount = new QuantityBase();
                        labelerInfo.SeenCount = new QuantityBase();
                        labelerInfo.SkippedCount = new QuantityBase();

                        #endregion
                    }
                    sameBatchLabelCase.State = SameBatchLabelCaseState.LabelerAssigned;
                    await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);

                    #endregion Update SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    #region Update ImageCategory QuantityItem

                    await UpdateImageCategoryQuantityItemAsync(session, imageCategoryDataManager, ultrasoundFileDataManager, imageCategory, imageBatch, imageCase);

                    #endregion

                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} clear labeled files to ImageCategory:{imageCategory.Name}, ImageBatch:{imageBatch.Name}, CaseName:{sameBatchLabelCase.Name}, AssignCount:{sameBatchLabelCase.AssignCount}.");
                    return;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        private static async Task UpdateImageCategoryQuantityItemAsync(AccountSession session, IImageCategoryDataManager imageCategoryDataManager, IUltrasoundFileDataManager ultrasoundFileDataManager, ImageCategory imageCategory, ImageCategory imageBatch, ImageCategory imageCase)
        {
            //ImageBatch
            var labeled = await ultrasoundFileDataManager.GetLabeledUltrasoundFileCountAsync(CategoryLevel.Batch, imageBatch.Id);
            var unAdoptable = await ultrasoundFileDataManager.GetUnAdoptableUltrasoundFileCountAsync(CategoryLevel.Batch, imageBatch.Id);
            var seen = await ultrasoundFileDataManager.GetHasSeenUltrasoundFileCountAsync(CategoryLevel.Batch, imageBatch.Id);
            var skipped = await ultrasoundFileDataManager.GetSkippedUltrasoundFileCountAsync(CategoryLevel.Batch, imageBatch.Id);
            imageBatch.FileItem.Quantity.Labeled = (int)labeled;
            imageBatch.FileItem.Quantity.UnLabeled = imageBatch.FileItem.Quantity.Total - (int)labeled;
            imageBatch.FileItem.Quantity.UnAdoptable = (int)unAdoptable;
            imageBatch.FileItem.Quantity.Seen = (int)seen;
            imageBatch.FileItem.Quantity.Skipped = (int)skipped;
            await imageCategoryDataManager.UpdateImageCategoryAsync(imageBatch);
            await SystemLogger.WriteLogAsync($"Admin - {session.Name} update imageBatch:{imageBatch.Name}, {JsonConvert.SerializeObject(imageBatch.FileItem.Quantity)}.");

            //ImageCategory
            var imageBatches = await imageCategoryDataManager.GetImageCategoriesByParentIdAsync(imageCategory.Id);
            labeled = imageBatches.Sum(x => x.FileItem.Quantity.Labeled);
            unAdoptable = imageBatches.Sum(x => x.FileItem.Quantity.UnAdoptable);
            seen = imageBatches.Sum(x => x.FileItem.Quantity.Seen);
            skipped = imageBatches.Sum(x => x.FileItem.Quantity.Skipped);
            imageCategory.FileItem.Quantity.Labeled = (int)labeled;
            imageCategory.FileItem.Quantity.UnLabeled = imageCategory.FileItem.Quantity.Total - (int)labeled;
            imageCategory.FileItem.Quantity.UnAdoptable = (int)unAdoptable;
            imageCategory.FileItem.Quantity.Seen = (int)seen;
            imageCategory.FileItem.Quantity.Skipped = (int)skipped;
            await imageCategoryDataManager.UpdateImageCategoryAsync(imageCategory);
            await SystemLogger.WriteLogAsync($"Admin - {session.Name} update imageCategory:{imageCategory.Name}, {JsonConvert.SerializeObject(imageCategory.FileItem.Quantity)}.");

            //ImageCase
            if (imageCase != null)
            {
                labeled = await ultrasoundFileDataManager.GetLabeledUltrasoundFileCountAsync(CategoryLevel.SameBatchLabelCase, imageCase.Id);
                unAdoptable = await ultrasoundFileDataManager.GetUnAdoptableUltrasoundFileCountAsync(CategoryLevel.SameBatchLabelCase, imageCase.Id);
                seen = await ultrasoundFileDataManager.GetHasSeenUltrasoundFileCountAsync(CategoryLevel.SameBatchLabelCase, imageCase.Id);
                skipped = await ultrasoundFileDataManager.GetSkippedUltrasoundFileCountAsync(CategoryLevel.SameBatchLabelCase, imageCase.Id);
                imageCase.FileItem.Quantity.Labeled = (int)labeled;
                imageCase.FileItem.Quantity.UnLabeled = imageCase.FileItem.Quantity.Total - (int)labeled;
                imageCase.FileItem.Quantity.UnAdoptable = (int)unAdoptable;
                imageCase.FileItem.Quantity.Seen = (int)seen;
                imageCase.FileItem.Quantity.Skipped = (int)skipped;
                await imageCategoryDataManager.UpdateImageCategoryAsync(imageCase);
                await SystemLogger.WriteLogAsync($"Admin - {session.Name} update imageCase:{imageCase.Name}, {JsonConvert.SerializeObject(imageCase.FileItem.Quantity)}.");
            }
        }

        /// <summary>
        /// Get archived image by archivedImageId
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="archivedImageId">The id of the archived image</param>
        /// <returns>The found archived image.</returns>
        public async Task<ArchivedImage> GetArchivedImageAsync(long sessionId, long archivedImageId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var archivedImageDataManager = databaseService.GetManager<IArchivedImageDataManager>();
                    var archivedImage = await archivedImageDataManager.GetArchivedImageAsync(archivedImageId);
                    if (archivedImage != null)
                    {
                        //if (isVideo)
                        //{
                        //    archivedImage.ImageData = await GetArchivedVideoData(archivedImage);
                        //}
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get archived image {archivedImageId}.");
                        return archivedImage;
                    }

                    throw new InvalidOperationException("ArchivedImageNotExist");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get ths labeler group
        /// </summary>
        /// <param name="imageCategoryId">The image category id</param>
        /// <param name="labelerId">The labeler id</param>
        /// <returns></returns>
        public async Task<LabelerGroup> GetLabelerGroupAsync(long sessionId, long imageCategoryId, long labelerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    long institutionId = 0;
                    var account = await accountDataManager.GetAccountAsync(labelerId);
                    if (account != null)
                    {
                        institutionId = account.InstitutionId;
                    }
                    return await labelerGroupDataManager.GetLabelerGroupAsync(labelerId, institutionId, imageCategoryId);

                    //throw new InvalidOperationException("LabelerGroupNotExist");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the sum of the assigned count of AssignedLabelCase.
        /// </summary>
        /// <param name="imageCategoryId">The image category id</param>
        /// <param name="labelerId">The labeler id</param>
        /// <returns></returns>
        public async Task<QuantityBase> GetAssignedCountForAssignedLabelCaseAsync(long sessionId, long imageCategoryId, long labelerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var count = new QuantityBase();
                    var assignedLabelCases = await caseDataManager.GetAssignedLabelCasesAsync(imageCategoryId, labelerId);
                    if (assignedLabelCases != null)
                    {
                        count.Group = assignedLabelCases.Sum(x => x.Count.Group);
                        count.File = assignedLabelCases.Sum(x => x.Count.File);
                    }
                    return count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the sum of the assigned ultrasound file count.
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetAssignedUltrasoundFileCountAsync(long sessionId, long imageBatchId, AssignCondition condition, int assignGroupCount)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    var assignUltrasoundGroups = new List<UltrasoundGroup>();
                    switch (condition)
                    {
                        case AssignCondition.UnAssigned:
                            assignUltrasoundGroups = await ultrasoundGroupDataManager.GetUnAssignedUnGoldStandardUltrasoundGroupsAsync(CategoryLevel.Batch, imageBatchId, 0, assignGroupCount);
                            break;

                        case AssignCondition.UnLabeled:
                            assignUltrasoundGroups = await ultrasoundGroupDataManager.GetUnLabeledUltrasoundGroupsAsync(CategoryLevel.Batch, imageBatchId, 0, assignGroupCount);
                            break;

                        case AssignCondition.UnAdoptable:
                            assignUltrasoundGroups = await ultrasoundGroupDataManager.GetUnAdopatableUnGoldStandardUltrasoundGroupsAsync(CategoryLevel.Batch, imageBatchId, 0, assignGroupCount);
                            break;

                        default:
                            break;
                    }
                    var assignUltrasoundGroupIds = assignUltrasoundGroups.Select(x => x.Id);
                    var count = await ultrasoundFileDataManager.GetUltrasoundFileCountAsync(assignUltrasoundGroupIds);
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Assign files to labelers.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="caseName">The label case name.</param>
        /// <param name="organization">The organization of label case.</param>
        /// <param name="imageCategoryId">The tag id of the images.</param>
        /// <param name="labelerInfos">The labelers to assign.</param>
        /// <param name="mode">The assign mode.</param>
        /// <param name="type">The assign type.</param>
        /// <param name="condition">The assign condition.</param>
        /// <param name="assignCount">The image count to assign.</param>
        /// <returns>The id of the assign operation.</returns>
        public async Task<OpResult> AssignLabelCaseAsync(long sessionId, long operationId, string caseName, EntityBase organization, long imageCategoryId, long imageBatchId, IEnumerable<AssignLabelerInfoModal> labelerInfos, AssignMode mode,
            AssignType type, AssignCondition condition, QuantityBase assignCount, VideoItem videoItem)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId, caseName);
                    if (imageCase != null)
                    {
                        throw new InvalidOperationException("DuplicateName");
                    }
                    var level = imageBatch.Level;
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var goldStandardFileDataManager = databaseService.GetManager<IGoldStandardFileDataManager>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var goldStandardAssignedFileDataManager = databaseService.GetManager<IGoldStandardAssignedFileDataManager>();
                    var selfCheckAssignedFileDataManager = databaseService.GetManager<ISelfCheckAssignedFileDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    var opencvSimUtils = new VideoFrameOpencvSimUtils();
                    string errorMsg = "";
                    #region Get assign UltrasoundGroups & UltrasoundFiles

                    var assignUltrasoundGroups = new List<UltrasoundGroup>();
                    var restCount = type == AssignType.DuplicateAssign ? labelerInfos.Select(x => x.AssignRestCount.Group).Max() : labelerInfos.Select(x => x.AssignRestCount.Group).Sum();
                    switch (condition)
                    {
                        case AssignCondition.UnAssigned:
                            assignUltrasoundGroups = await ultrasoundGroupDataManager.GetUnAssignedUnGoldStandardUltrasoundGroupsAsync(level, imageBatchId, 0, restCount);
                            break;

                        case AssignCondition.UnLabeled:
                            assignUltrasoundGroups = await ultrasoundGroupDataManager.GetUnLabeledUltrasoundGroupsAsync(level, imageBatchId, 0, restCount);
                            break;

                        case AssignCondition.UnAdoptable:
                            assignUltrasoundGroups = await ultrasoundGroupDataManager.GetUnAdopatableUnGoldStandardUltrasoundGroupsAsync(level, imageBatchId, 0, restCount);
                            break;

                        default:
                            break;
                    }

                    if (restCount > assignUltrasoundGroups.Count)
                    {
                        throw new InvalidOperationException("InsufficientImages");
                    }

                    assignCount.File = 0;
                    var assignUltrasoundModels = new List<AssignUltrasoundModel>();
                    var modalItems = new List<ModalQuantityItem>();
                    Dictionary<long, DevelopConfirmStatus> developConfirmStatusInGroupDict = new Dictionary<long, DevelopConfirmStatus>();
                    foreach (var group in assignUltrasoundGroups)
                    {
                        var assignUltrasoundModel = new AssignUltrasoundModel
                        {
                            Group = group,
                        };
                        var ultrasoundFiles = await ultrasoundFileDataManager.GetUltrasoundFilesExcludePreviewImageAsync(group.Id);
                        if (ultrasoundFiles != null)
                        {
                            assignUltrasoundModel.Files = ultrasoundFiles;
                            foreach (var ultrasoundFile in ultrasoundFiles)
                            {
                                var modalItem = modalItems.FirstOrDefault(x => x.Modal.Id == ultrasoundFile.Modal.Id || x.Modal.Title == ultrasoundFile.Modal.Title);
                                if (modalItem == null)
                                {
                                    modalItem = new ModalQuantityItem
                                    {
                                        Modal = ultrasoundFile.Modal,
                                    };
                                    modalItems.Add(modalItem);
                                }
                                if (ultrasoundFile.IsVideo && videoItem.FrameMode == FrameMode.EqualInterval)
                                {
                                    if (!developConfirmStatusInGroupDict.ContainsKey(group.Id))
                                    {
                                        developConfirmStatusInGroupDict.Add(group.Id, DevelopConfirmStatus.WaitForConfirm);
                                    }
                                }
                                modalItem.Quantity.Total++;
                                modalItem.Quantity.UnLabeled++;
                                assignCount.File++;
                                assignUltrasoundModel.FileFrameCount += ultrasoundFile.FrameCount;
                            }
                            if (!developConfirmStatusInGroupDict.ContainsKey(group.Id))
                            {
                                developConfirmStatusInGroupDict.Add(group.Id, DevelopConfirmStatus.None);
                            }
                        }
                        assignUltrasoundModels.Add(assignUltrasoundModel);
                    }

                    #endregion Get assign UltrasoundGroups & UltrasoundFiles

                    #region Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    DevelopConfirmInfo totalDevelopConfirmInfo = new DevelopConfirmInfo();
                    if (developConfirmStatusInGroupDict.ContainsValue(DevelopConfirmStatus.WaitForConfirm))
                    {
                        totalDevelopConfirmInfo.Status = DevelopConfirmStatus.WaitForConfirm;
                    }
                    var sameBatchLabelCase = new SameBatchLabelCase
                    {
                        Name = caseName,
                        Organization = organization,
                        ImageCategoryId = imageCategoryId,
                        ImageBatchId = imageBatchId,
                        Mode = mode,
                        Type = type,
                        Condition = condition,
                        AssignCount = assignCount,
                        State = SameBatchLabelCaseState.LabelerAssigned,
                        VideoItem = videoItem,
                        DevelopConfirmInfo = totalDevelopConfirmInfo,
                    };

                    #region Create ImageCategory

                    imageCase = new ImageCategory
                    {
                        Name = caseName,
                        Level = CategoryLevel.SameBatchLabelCase,
                        Parent = new EntityBase { Id = imageBatch.Id, Name = imageBatch.Name },
                        OrganizationId = organization.Id,
                        LabelPackageContentId = imageCategory.LabelPackageContentId,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                        Labelers = labelerInfos.Select(x => new EntityBase { Id = x.Id, Name = x.Name }).ToList(),
                        DevelopConfirmInfo = totalDevelopConfirmInfo
                    };
                    imageCase.GroupItem.Quantity.Total = assignCount.Group;
                    imageCase.GroupItem.Quantity.UnLabeled = assignCount.Group;
                    imageCase.FileItem.Quantity.Total = assignCount.File;
                    imageCase.FileItem.Quantity.UnLabeled = assignCount.File;
                    imageCase.ModalItems = modalItems;
                    await imageCategoryDataManager.CreateImageCategoryAsync(imageCase);
                    await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(imageBatch.Id, true);

                    #endregion Create ImageCategory

                    var labelerCount = labelerInfos.Count();
                    var assignIndex = 0;
                    var assignTotal = type == AssignType.DuplicateAssign ? assignCount.Group * labelerCount : assignCount.Group;
                    var eachStartIndex = 0;
                    foreach (var labelerInfo in labelerInfos)
                    {
                        #region Create AssignedLabelCase

                        var caseIndex = 0;
                        var lastAssignedCase = await caseDataManager.GetLastIndexAssignedLabelCaseAsync(labelerInfo.Id, imageCategoryId);
                        if (lastAssignedCase == null)
                        {
                            caseIndex = (int)await caseDataManager.GetAssignedLabelCaseCountAsync(labelerInfo.Id);
                        }
                        else
                        {
                            caseIndex = lastAssignedCase.CaseIndex + 1;
                        }
                        var account = await accountDataManager.GetAccountAsync(labelerInfo.Id);
                        if (account != null)
                        {
                            labelerInfo.InstitutionId = account.InstitutionId;
                        }
                        var assignedLabelCase = new AssignedLabelCase()
                        {
                            Name = sameBatchLabelCase.Name,
                            Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name },
                            SameBatchLabelCaseId = sameBatchLabelCase.Id,
                            OrganizationId = organization.Id,
                            ImageCategoryId = imageCategoryId,
                            ImageBatchId = imageBatchId,
                            ImageCaseId = imageCase.Id,
                            LabelPackageContentId = imageCategory.LabelPackageContentId,
                            InstitutionId = labelerInfo.InstitutionId,
                            Mode = mode,
                            CaseIndex = caseIndex,
                            VideoItem = videoItem,
                            DevelopConfirmInfo = totalDevelopConfirmInfo,
                        };
                        await caseDataManager.CreateAssignedLabelCaseAsync(assignedLabelCase);

                        #endregion Create AssignedLabelCase

                        #region Create AssignedLabelCaseGroup & AssignedLabelCaseFile

                        #region Add eachCount

                        labelerInfo.AssignCount.File = 0;
                        var count = new QuantityBase();
                        var assignFrameTotal = 0;
                        var requiredFrameTotal = 0;
                        if (type == AssignType.DuplicateAssign)
                        {
                            eachStartIndex = 0;
                        }
                        for (var i = 0; i < labelerInfo.AssignRestCount.Group; i++)
                        {
                            var assignUltrasoundModel = assignUltrasoundModels[eachStartIndex];
                            var ultrasoundGroup = assignUltrasoundModel.Group;
                            var developConfirmInfoInGroup = new DevelopConfirmInfo();
                            developConfirmInfoInGroup.Status = developConfirmStatusInGroupDict[ultrasoundGroup.Id];
                            var assignedLabelCaseGroup = new AssignedLabelCaseGroup
                            {
                                ImageCategoryId = imageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                UltrasoundGroupId = ultrasoundGroup.Id,
                                Index = count.Group,
                                DevelopConfirmInfo = developConfirmInfoInGroup,
                            };
                            await caseDataManager.CreateAssignedLabelCaseGroupAsync(assignedLabelCaseGroup);

                            #region Update UltrasoundGroup

                            var isUpdateUltrasoundGroup = false;
                            ultrasoundGroup.ImageCaseInfos ??= new List<ImageCaseInfo>();
                            if (!ultrasoundGroup.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                            {
                                ultrasoundGroup.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                isUpdateUltrasoundGroup = true;
                            }
                            if (!ultrasoundGroup.Assigned)
                            {
                                ultrasoundGroup.Assigned = true;
                                isUpdateUltrasoundGroup = true;

                                imageCategory.GroupItem.Quantity.UnAssigned--;
                                imageBatch.GroupItem.Quantity.UnAssigned--;
                            }
                            if (isUpdateUltrasoundGroup)
                            {
                                await ultrasoundGroupDataManager.UpdateUltrasoundGroupAsync(ultrasoundGroup);
                            }

                            #endregion Update UltrasoundGroup

                            if (videoItem.IntervalFrame <= 0)
                            {
                                videoItem.IntervalFrame = 1;
                            }
                            var requiredFrame = 0;
                            foreach (var ultrasoundFile in assignUltrasoundModel.Files)
                            {
                                var developConfirmInfoInFile = new DevelopConfirmInfo();
                                List<int> keyFrameIndexList = new List<int>();
                                if (ultrasoundFile.IsVideo)
                                {
                                    switch (videoItem.FrameMode)
                                    {
                                        case FrameMode.EqualInterval:
                                            developConfirmInfoInFile.Status = DevelopConfirmStatus.WaitForConfirm;
                                            var result = opencvSimUtils.VideoFrameSimilarity(ultrasoundFile.Source.FileFullName, 1, (float)videoItem.SimilarityThreshold, videoItem.IntervalFrame, out var frameCount, out var keyFrameIndexListFromAI);
                                            if (result)
                                            {
                                                if (frameCount != ultrasoundFile.FrameCount)
                                                {
                                                    string msg = $"AssignLabelCaseAsync FrameCount is Different:FrameCount is {ultrasoundFile.FrameCount},FrameCount read by opencvSimUtils is {frameCount}";
                                                    Logger.WriteLineError(msg);
                                                    errorMsg += msg + "\r\n";
                                                }
                                                if (keyFrameIndexListFromAI != null)
                                                {
                                                    foreach (var keyFrame in keyFrameIndexListFromAI)
                                                    {
                                                        keyFrameIndexList.Add(keyFrame - 1);//AI给出的结果是从索引1开始
                                                    }
                                                }
                                                else
                                                {
                                                    string msg = $"AssignLabelCaseAsync KeyFrameList From AI is Null";
                                                    Logger.WriteLineError(msg);
                                                    errorMsg += msg + "\r\n";
                                                }
                                            }
                                            else
                                            {
                                                string msg = $"AssignLabelCaseAsync Error:VideoFrameSimilarity Error result is failed";
                                                Logger.WriteLineError(msg);
                                                errorMsg += msg + "\r\n";
                                            }
                                            if (keyFrameIndexList.Count == 0)
                                            {
                                                for (int j = 0; j < ultrasoundFile.FrameCount; j += videoItem.IntervalFrame)
                                                {
                                                    keyFrameIndexList.Add(j);
                                                }
                                            }
                                            break;

                                        case FrameMode.MaxInterval:
                                            for (int j = 0; j < ultrasoundFile.FrameCount; j += videoItem.IntervalFrame)
                                            {
                                                keyFrameIndexList.Add(j);
                                            }
                                            break;
                                    }
                                    requiredFrame += keyFrameIndexList.Count;
                                }
                                else
                                {
                                    requiredFrame++;
                                }
                                var assignedLabelCaseFile = new AssignedLabelCaseFile
                                {
                                    ImageCategoryId = imageCategoryId,
                                    AssignedLabelCaseGroupId = assignedLabelCaseGroup.Id,
                                    AssignedLabelCaseId = assignedLabelCase.Id,
                                    UltrasoundFileId = ultrasoundFile.Id,
                                    Index = ultrasoundFile.Index,
                                    IsLabeled = false,
                                    IsVideo = ultrasoundFile.IsVideo,
                                    KeyFrameIndexList = keyFrameIndexList,
                                    VideoItem = videoItem,
                                    DevelopConfirmInfo = developConfirmInfoInFile,
                                };
                                await caseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                                count.File++;
                                labelerInfo.AssignCount.File++;

                                #region Update UltrasoundFile

                                var isUpdateUltrasoundFile = false;
                                if (!ultrasoundFile.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                                {
                                    ultrasoundFile.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                    isUpdateUltrasoundFile = true;
                                }
                                if (!ultrasoundFile.Assigned)
                                {
                                    ultrasoundFile.Assigned = true;
                                    isUpdateUltrasoundFile = true;

                                    imageCategory.FileItem.Quantity.UnAssigned--;
                                    imageBatch.FileItem.Quantity.UnAssigned--;
                                }
                                if (isUpdateUltrasoundFile)
                                {
                                    await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);
                                }

                                #endregion Update UltrasoundFile
                            }
                            count.Group++;
                            assignIndex++;
                            eachStartIndex++;
                            assignFrameTotal += assignUltrasoundModel.FileFrameCount;
                            requiredFrameTotal += requiredFrame;
                            var progress = (int)((double)assignIndex / assignTotal * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }
                        switch (imageCategory.DevelopConfirmInfo.Status)
                        {
                            case DevelopConfirmStatus.None:
                            case DevelopConfirmStatus.HasConfirmed:
                                if (totalDevelopConfirmInfo.Status == DevelopConfirmStatus.WaitForConfirm)
                                {
                                    imageCategory.DevelopConfirmInfo.Status = DevelopConfirmStatus.WaitForConfirm;
                                    imageCategory.DevelopConfirmInfo.Developer = new EntityBase();
                                    imageCategory.DevelopConfirmInfo.ConfirmTime = DateTime.MinValue.ToUniversalTime();
                                }
                                break;
                        }
                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageCategory);
                        switch (imageBatch.DevelopConfirmInfo.Status)
                        {
                            case DevelopConfirmStatus.None:
                            case DevelopConfirmStatus.HasConfirmed:
                                if (totalDevelopConfirmInfo.Status == DevelopConfirmStatus.WaitForConfirm)
                                {
                                    imageBatch.DevelopConfirmInfo.Status = DevelopConfirmStatus.WaitForConfirm;
                                    imageBatch.DevelopConfirmInfo.Developer = new EntityBase();
                                    imageBatch.DevelopConfirmInfo.ConfirmTime = DateTime.MinValue.ToUniversalTime();
                                }
                                break;
                        }
                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageBatch);

                        #endregion Add eachCount

                        #region Add goldStandardFilesCount

                        labelerInfo.AddGoldStandardCount.File = 0;
                        var actualAddedGoldStandardCount = 0;
                        var ultrasoundFileIds = new List<long>();
                        if (labelerInfo.AddGoldStandardCount.Group > 0)
                        {
                            var goldStandardAssignedFiles = await goldStandardAssignedFileDataManager.GetGoldStandardAssignedFilesAsync(imageCategoryId, labelerInfo.Id);
                            if (goldStandardAssignedFiles.Any())
                            {
                                ultrasoundFileIds = goldStandardAssignedFiles.Select(x => x.UltrasoundFileId).ToList();
                            }
                            var goldStandardFiles = await goldStandardFileDataManager.GetGoldStandardFilesExcludeUltrasoundFileIdsAsync(imageCategoryId, ultrasoundFileIds, labelerInfo.AddGoldStandardCount.Group);
                            foreach (var goldStandardFile in goldStandardFiles)
                            {
                                var ultrasoundFileId = goldStandardFile.UltrasoundFileId;
                                var assignedLabelCaseFile = new AssignedLabelCaseFile()
                                {
                                    ImageCategoryId = imageCategoryId,
                                    AssignedLabelCaseId = assignedLabelCase.Id,
                                    UltrasoundFileId = ultrasoundFileId,
                                    Index = count.File,
                                    IsLabeled = false,
                                    MixedFileType = MixedFileType.GoldStandard,
                                    IsVideo = goldStandardFile.IsVideo,
                                };
                                await caseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                                labelerInfo.AddGoldStandardCount.File++;
                                count.File++;
                                assignIndex++;

                                #region Update UltrasoundFile

                                var isUpdateUltrasoundFile = false;
                                var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(ultrasoundFileId);
                                if (!ultrasoundFile.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                                {
                                    ultrasoundFile.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                    isUpdateUltrasoundFile = true;
                                }
                                if (!ultrasoundFile.Assigned)
                                {
                                    ultrasoundFile.Assigned = true;
                                    isUpdateUltrasoundFile = true;
                                }
                                if (isUpdateUltrasoundFile)
                                {
                                    await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);
                                }

                                #endregion Update UltrasoundFile

                                #region Add GoldStandardAssignedFile

                                var goldStandardAssignedFile = await goldStandardAssignedFileDataManager.GetGoldStandardAssignedFileByUltrasoundFileIdAsync(ultrasoundFileId);
                                if (goldStandardAssignedFile == null)
                                {
                                    goldStandardAssignedFile = new GoldStandardAssignedFile
                                    {
                                        ImageCategoryId = imageCategoryId,
                                        UltrasoundFileId = ultrasoundFileId,
                                    };
                                    var labelerAssignedInfo = new LabelerAssignedInfo
                                    {
                                        Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name }
                                    };
                                    labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                    goldStandardAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                    await goldStandardAssignedFileDataManager.CreateGoldStandardAssignedFileAsync(goldStandardAssignedFile);
                                    actualAddedGoldStandardCount++;
                                }
                                else
                                {
                                    var isUpdate = false;
                                    var labelerAssignedInfo = goldStandardAssignedFile.LabelerAssignedInfos.FirstOrDefault(x => x.Labeler.Id == labelerInfo.Id);
                                    if (labelerAssignedInfo == null)
                                    {
                                        labelerAssignedInfo = new LabelerAssignedInfo
                                        {
                                            Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name }
                                        };
                                        labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                        goldStandardAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                        isUpdate = true;
                                    }
                                    else if (!labelerAssignedInfo.FileInfos.Exists(x => x.AssignedLabelCaseFileId == assignedLabelCaseFile.Id))
                                    {
                                        labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                        goldStandardAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                        isUpdate = true;
                                    }
                                    if (isUpdate)
                                    {
                                        await goldStandardAssignedFileDataManager.UpdateGoldStandardAssignedFileAsync(goldStandardAssignedFile);
                                        actualAddedGoldStandardCount++;
                                    }
                                }
                                #endregion Add GoldStandardAssignedFile

                                var progress = (int)((double)assignIndex / assignTotal * 100);
                                OperationManager.SetProgress(operationId, progress);
                            }
                        }

                        #endregion Add goldStandardFilesCount

                        #region Add selfCheckFilesCount

                        labelerInfo.AddSelfCheckCount.File = 0;
                        var actualAddedSelfCheckCount = 0;
                        if (labelerInfo.AddSelfCheckCount.Group > 0)
                        {
                            var selfCheckAssignedFiles = await selfCheckAssignedFileDataManager.GetSelfCheckAssignedFilesAsync(imageCategoryId, labelerInfo.Id);
                            if (selfCheckAssignedFiles.Any())
                            {
                                ultrasoundFileIds.AddRange(selfCheckAssignedFiles.Select(x => x.UltrasoundFileId));
                            }
                            var selfCheckFiles = await caseDataManager.GetAssignedLabelCaseFilesExcludeUltrasoundFileIdsAsync(imageCategoryId, ultrasoundFileIds, labelerInfo.AddSelfCheckCount.Group);
                            foreach (var selfCheckFile in selfCheckFiles)
                            {
                                var ultrasoundFileId = selfCheckFile.UltrasoundFileId;
                                var assignedLabelCaseFile = new AssignedLabelCaseFile
                                {
                                    ImageCategoryId = imageCategoryId,
                                    AssignedLabelCaseId = assignedLabelCase.Id,
                                    UltrasoundFileId = ultrasoundFileId,
                                    Index = count.File,
                                    IsLabeled = false,
                                    MixedFileType = MixedFileType.SelfCheck,
                                    IsVideo = selfCheckFile.IsVideo,
                                };
                                await caseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                                labelerInfo.AddSelfCheckCount.File++;
                                count.File++;
                                assignIndex++;

                                #region Add SelfCheckAssignedFile

                                var selfCheckAssignedFile = await selfCheckAssignedFileDataManager.GetSelfCheckAssignedFileByUltrasoundFileIdAsync(ultrasoundFileId);
                                if (selfCheckAssignedFile == null)
                                {
                                    selfCheckAssignedFile = new SelfCheckAssignedFile
                                    {
                                        ImageCategoryId = imageCategoryId,
                                        UltrasoundFileId = ultrasoundFileId,
                                    };
                                    var labelerAssignedInfo = new LabelerAssignedInfo
                                    {
                                        Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name }
                                    };
                                    labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                    selfCheckAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                    await selfCheckAssignedFileDataManager.CreateSelfCheckAssignedFileAsync(selfCheckAssignedFile);
                                    actualAddedSelfCheckCount++;
                                }
                                else
                                {
                                    var isUpdate = false;
                                    var labelerAssignedInfo = selfCheckAssignedFile.LabelerAssignedInfos.FirstOrDefault(x => x.Labeler.Id == labelerInfo.Id);
                                    if (labelerAssignedInfo == null)
                                    {
                                        labelerAssignedInfo = new LabelerAssignedInfo
                                        {
                                            Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name }
                                        };
                                        labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                        selfCheckAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                        isUpdate = true;
                                    }
                                    else if (!labelerAssignedInfo.FileInfos.Exists(x => x.AssignedLabelCaseFileId == assignedLabelCaseFile.Id))
                                    {
                                        labelerAssignedInfo.FileInfos.Add(new FileInfoBase { AssignedLabelCaseFileId = assignedLabelCaseFile.Id });
                                        selfCheckAssignedFile.LabelerAssignedInfos.Add(labelerAssignedInfo);
                                        isUpdate = true;
                                    }
                                    if (isUpdate)
                                    {
                                        await selfCheckAssignedFileDataManager.UpdateSelfCheckAssignedFileAsync(selfCheckAssignedFile);
                                        actualAddedSelfCheckCount++;
                                    }
                                }
                                #endregion Add SelfCheckAssignedFile

                                var progress = (int)((double)assignIndex / assignTotal * 100);
                                OperationManager.SetProgress(operationId, progress);
                            }
                        }

                        #endregion Add selfCheckFilesCount

                        #endregion Create AssignedLabelCaseGroup & AssignedLabelCaseFile

                        #region Update AssignedLabelCase

                        assignedLabelCase.Count = count;
                        await caseDataManager.UpdateAssignCaseAsync(assignedLabelCase);
                        await caseDataManager.AddAndReorderIndexToAssignedLabelCasesAsync(assignedLabelCase);

                        if (assignCount.File < count.File)
                        {
                            assignCount.File = count.File;
                            imageCase.FileItem.Quantity.Total = assignCount.File;
                            imageCase.FileItem.Quantity.UnLabeled = assignCount.File;
                            await imageCategoryDataManager.UpdateImageCategoryAsync(imageCase);
                        }

                        #endregion Update AssignedLabelCase

                        #region Add SameBatchLabelCase Labelers

                        labelerInfo.AssignRestCount.File = labelerInfo.AssignCount.File - labelerInfo.AddGoldStandardCount.File - labelerInfo.AddSelfCheckCount.File;
                        sameBatchLabelCase.Labelers.Add(new SameBatchLabelerInfo
                        {
                            Id = labelerInfo.Id,
                            Name = labelerInfo.Name,
                            State = labelerInfo.State,
                            AssignCount = labelerInfo.AssignCount,
                            AssignRestCount = labelerInfo.AssignRestCount,
                            AddGoldStandardCount = labelerInfo.AddGoldStandardCount,
                            AddSelfCheckCount = labelerInfo.AddSelfCheckCount,
                            AssignedLabelCaseId = assignedLabelCase.Id,
                            InstitutionId = labelerInfo.InstitutionId,
                        });

                        #endregion Add SameBatchLabelCase Labelers

                        #region Create LabelerGroup

                        var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(labelerInfo.Id, labelerInfo.InstitutionId, imageCategory.Id);
                        if (labelerGroup == null)
                        {
                            labelerGroup = new LabelerGroup
                            {
                                Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name },
                                ImageCategoryId = imageCategory.Id,
                                OrganizationId = imageCategory.OrganizationId,
                                LabelCaseQuantityItem = new AssignedCaseQuantityItem
                                {
                                    Total = assignFrameTotal,
                                },
                                GoldStandardAssignedCount = actualAddedGoldStandardCount,
                                SelfCheckAssignedCount = actualAddedSelfCheckCount,
                            };
                            if (!developConfirmStatusInGroupDict.ContainsValue(DevelopConfirmStatus.WaitForConfirm))
                            {
                                labelerGroup.LabelCaseQuantityItem.Remaining += requiredFrameTotal;
                                labelerGroup.LabelCaseQuantityItem.Required += requiredFrameTotal;
                            }
                            await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                        }
                        else
                        {
                            labelerGroup.LabelCaseQuantityItem.Total += assignFrameTotal;
                            labelerGroup.GoldStandardAssignedCount += actualAddedGoldStandardCount;
                            labelerGroup.SelfCheckAssignedCount += actualAddedSelfCheckCount;
                            if (!developConfirmStatusInGroupDict.ContainsValue(DevelopConfirmStatus.WaitForConfirm))
                            {
                                labelerGroup.LabelCaseQuantityItem.Remaining += requiredFrameTotal;
                                labelerGroup.LabelCaseQuantityItem.Required += requiredFrameTotal;
                            }
                            await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                        }
                        #endregion Create LabelerGroup
                    }

                    sameBatchLabelCase.ImageCaseId = imageCase.Id;
                    await sameBatchLabelCaseDataManager.CreateSameBatchLabelCaseAsync(sameBatchLabelCase);

                    #endregion Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    OperationManager.SetProgress(operationId, 100);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} assigned files to Labelers:[{JsonConvert.SerializeObject(labelerInfos)}], ImageCategory:{imageCategory.Name}, ImageBatch:{imageBatch.Name}, CaseName:{caseName}, AssignCount:{assignCount.Group}.");
                    return new OpResult
                    {
                        ResultCode = OpResultCode.Success,
                        Message = errorMsg
                    };
                }
            }
            return new OpResult
            {
                ResultCode = OpResultCode.InvalidSession,
            };
        }

        /// <summary>
        /// Assign files to labelers.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="caseName">The label case name.</param>
        /// <param name="organization">The organization of label case.</param>
        /// <param name="imageCategoryId">The tag id of the images.</param>
        /// <param name="labelerInfos">The labelers to assign.</param>
        /// <param name="mode">The assign mode.</param>
        /// <param name="type">The assign type.</param>
        /// <returns>The id of the assign operation.</returns>
        public async Task<long> AssignDisputeLabelCaseAsync(long sessionId, string caseName, EntityBase organization, long imageCategoryId, long imageBatchId, List<SameBatchLabelerInfo> labelerInfos, AssignMode mode,
            AssignType type, List<long> ultrasoundGroupIds)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId, caseName);
                    if (imageCase != null)
                    {
                        throw new InvalidOperationException("DuplicateName");
                    }
                    var level = imageBatch.Level;
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var disputeUltrasoundFileDataManger = databaseService.GetManager<IDisputeUltrasoundFileDataManager>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var goldStandardFileDataManager = databaseService.GetManager<IGoldStandardFileDataManager>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var goldStandardAssignedFileDataManager = databaseService.GetManager<IGoldStandardAssignedFileDataManager>();
                    var selfCheckAssignedFileDataManager = databaseService.GetManager<ISelfCheckAssignedFileDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var operationId = IdCreator.CreateId();

                    #region Get assign Dispute UltrasoundGroups & UltrasoundFiles

                    var assignCount = new QuantityBase { Group = ultrasoundGroupIds.Count() };
                    var assignUltrasoundModels = new List<AssignDisputeUltrasoundModel>();
                    var assignUltrasoundGroups = await disputeUltrasoundFileDataManger.GetDisputeUltrasoundGroupsAsync(ultrasoundGroupIds);
                    var modalItems = new List<ModalQuantityItem>();
                    foreach (var group in assignUltrasoundGroups)
                    {
                        var assignUltrasoundModel = new AssignDisputeUltrasoundModel
                        {
                            Group = group,
                        };
                        var ultrasoundFiles = await disputeUltrasoundFileDataManger.GetDisputeUltrasoundFilesExcludePreviewImageAsync(group.Id);
                        if (ultrasoundFiles != null)
                        {
                            assignUltrasoundModel.Files = ultrasoundFiles;
                            foreach (var ultrasoundFile in ultrasoundFiles)
                            {
                                var modalItem = modalItems.FirstOrDefault(x => x.Modal.Id == ultrasoundFile.Modal.Id || x.Modal.Title == ultrasoundFile.Modal.Title);
                                if (modalItem == null)
                                {
                                    modalItem = new ModalQuantityItem
                                    {
                                        Modal = ultrasoundFile.Modal,
                                    };
                                    modalItems.Add(modalItem);
                                }
                                modalItem.Quantity.Total++;
                                modalItem.Quantity.UnLabeled++;
                            }
                        }
                        assignUltrasoundModels.Add(assignUltrasoundModel);
                        assignCount.File++;
                    }

                    #endregion Get assign Dispute UltrasoundGroups & UltrasoundFiles

                    #region Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    var sameBatchLabelCase = new SameBatchLabelCase
                    {
                        Name = caseName,
                        Organization = organization,
                        ImageCategoryId = imageCategoryId,
                        ImageBatchId = imageBatchId,
                        Mode = mode,
                        Type = type,
                        Condition = AssignCondition.Dispute,
                        AssignCount = assignCount,
                        State = SameBatchLabelCaseState.LabelerAssigned,
                        VideoItem = imageCategory.VideoItem,
                    };

                    #region Create ImageCategory

                    imageCase = new ImageCategory
                    {
                        Name = caseName,
                        Level = CategoryLevel.SameBatchLabelCase,
                        Parent = new EntityBase { Id = imageBatch.Id, Name = imageBatch.Name },
                        OrganizationId = organization.Id,
                        LabelPackageContentId = imageCategory.LabelPackageContentId,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                        Labelers = labelerInfos.Select(x => new EntityBase { Id = x.Id, Name = x.Name }).ToList(),
                    };
                    imageCase.GroupItem.Quantity.Total = assignCount.Group;
                    imageCase.GroupItem.Quantity.UnLabeled = assignCount.Group;
                    imageCase.FileItem.Quantity.Total = assignCount.File;
                    imageCase.FileItem.Quantity.UnLabeled = assignCount.File;
                    imageCase.ModalItems = modalItems;
                    await imageCategoryDataManager.CreateImageCategoryAsync(imageCase);
                    await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(imageBatch.Id, true);

                    #endregion Create ImageCategory

                    var labelerCount = labelerInfos.Count();
                    var assignIndex = 0;
                    var assignTotal = type == AssignType.DuplicateAssign ? assignCount.File * labelerCount : assignCount.File;
                    var eachStartIndex = 0;
                    foreach (var labelerInfo in labelerInfos)
                    {
                        #region Create AssignedLabelCase

                        var caseIndex = 0;
                        var lastAssignedCase = await caseDataManager.GetLastIndexAssignedLabelCaseAsync(labelerInfo.Id, imageCategoryId);
                        if (lastAssignedCase == null)
                        {
                            caseIndex = (int)await caseDataManager.GetAssignedLabelCaseCountAsync(labelerInfo.Id);
                        }
                        else
                        {
                            caseIndex = lastAssignedCase.CaseIndex + 1;
                        }
                        var account = await accountDataManager.GetAccountAsync(labelerInfo.Id);
                        if (account != null)
                        {
                            labelerInfo.InstitutionId = account.InstitutionId;
                        }
                        var assignedLabelCase = new AssignedLabelCase()
                        {
                            Name = sameBatchLabelCase.Name,
                            Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name },
                            SameBatchLabelCaseId = sameBatchLabelCase.Id,
                            OrganizationId = organization.Id,
                            ImageCategoryId = imageCategoryId,
                            ImageBatchId = imageBatchId,
                            ImageCaseId = imageCase.Id,
                            LabelPackageContentId = imageCategory.LabelPackageContentId,
                            InstitutionId = labelerInfo.InstitutionId,
                            Mode = mode,
                            CaseIndex = caseIndex,
                        };
                        await caseDataManager.CreateAssignedLabelCaseAsync(assignedLabelCase);

                        #endregion Create AssignedLabelCase

                        #region Create AssignedLabelCaseFile

                        #region Add eachCount

                        labelerInfo.AssignCount.File = 0;
                        var count = new QuantityBase();
                        if (type == AssignType.DuplicateAssign)
                        {
                            eachStartIndex = 0;
                        }
                        for (var i = 0; i < assignCount.Group; i++)
                        {
                            var assignUltrasoundModel = assignUltrasoundModels[eachStartIndex];
                            var ultrasoundGroup = assignUltrasoundModel.Group;
                            var assignedLabelCaseGroup = new AssignedLabelCaseGroup
                            {
                                ImageCategoryId = imageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                UltrasoundGroupId = ultrasoundGroup.Id,
                                Index = count.Group,
                            };
                            await caseDataManager.CreateAssignedLabelCaseGroupAsync(assignedLabelCaseGroup);

                            #region Update UltrasoundGroup

                            ultrasoundGroup.ImageCaseInfos ??= new List<ImageCaseInfo>();
                            if (!ultrasoundGroup.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                            {
                                ultrasoundGroup.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                await disputeUltrasoundFileDataManger.UpdateDisputeUltrasoundGroupAsync(ultrasoundGroup);
                            }

                            #endregion

                            foreach (var ultrasoundFile in assignUltrasoundModel.Files)
                            {
                                var assignedLabelCaseFile = new AssignedLabelCaseFile()
                                {
                                    ImageCategoryId = imageCategoryId,
                                    AssignedLabelCaseId = assignedLabelCase.Id,
                                    UltrasoundFileId = ultrasoundFile.Id,
                                    Index = ultrasoundFile.Index,
                                    IsLabeled = false,
                                    IsVideo = ultrasoundFile.IsVideo,
                                };
                                await caseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                                count.File++;

                                #region Update UltrasoundFile

                                if (!ultrasoundFile.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                                {
                                    ultrasoundFile.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                    await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);
                                }

                                #endregion
                            }
                            count.Group++;
                            assignIndex++;
                            eachStartIndex++;

                            var progress = (int)((double)assignIndex / assignTotal * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }

                        #endregion Add eachCount

                        #endregion Create AssignedLabelCaseFile

                        #region Update AssignedLabelCase

                        assignedLabelCase.Count = count;
                        await caseDataManager.UpdateAssignCaseAsync(assignedLabelCase);
                        await caseDataManager.AddAndReorderIndexToAssignedLabelCasesAsync(assignedLabelCase);

                        if (assignCount.File < count.File)
                        {
                            assignCount.File = count.File;
                            imageCase.FileItem.Quantity.Total = assignCount.File;
                            imageCase.FileItem.Quantity.UnLabeled = assignCount.File;
                            await imageCategoryDataManager.UpdateImageCategoryAsync(imageCase);
                        }

                        #endregion

                        #region Add SameBatchLabelCase Labelers

                        sameBatchLabelCase.Labelers.Add(new SameBatchLabelerInfo
                        {
                            Id = labelerInfo.Id,
                            Name = labelerInfo.Name,
                            State = labelerInfo.State,
                            AssignCount = labelerInfo.AssignCount,
                            AssignRestCount = labelerInfo.AssignRestCount,
                            AddGoldStandardCount = labelerInfo.AddGoldStandardCount,
                            AddSelfCheckCount = labelerInfo.AddSelfCheckCount,
                            AssignedLabelCaseId = assignedLabelCase.Id,
                            InstitutionId = labelerInfo.InstitutionId,
                        });

                        #endregion

                        #region Create LabelerGroup

                        var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(labelerInfo.Id, labelerInfo.InstitutionId, imageCategory.Id);
                        if (labelerGroup == null)
                        {
                            labelerGroup = new LabelerGroup
                            {
                                Labeler = new EntityBase { Id = labelerInfo.Id, Name = labelerInfo.Name },
                                ImageCategoryId = imageCategory.Id,
                                OrganizationId = imageCategory.OrganizationId,
                                LabelCaseQuantityItem = new AssignedCaseQuantityItem
                                {
                                    Total = assignedLabelCase.Count.File,
                                    Remaining = assignedLabelCase.Count.File,
                                },
                            };
                            await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                        }
                        else
                        {
                            labelerGroup.LabelCaseQuantityItem.Total += assignedLabelCase.Count.File;
                            labelerGroup.LabelCaseQuantityItem.Remaining += assignedLabelCase.Count.File;
                            await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                        }
                        #endregion
                    }

                    sameBatchLabelCase.ImageCaseId = imageCase.Id;
                    await sameBatchLabelCaseDataManager.CreateSameBatchLabelCaseAsync(sameBatchLabelCase);

                    #endregion Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    await disputeUltrasoundFileDataManger.UpdateDisputeUltrasoundFileIsAssignAsync(ultrasoundGroupIds, true);
                    OperationManager.SetProgress(operationId, 100);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} assigned files to Labelers:[{JsonConvert.SerializeObject(labelerInfos)}], ImageCategory:{imageCategory.Name}, ImageBatch:{imageBatch.Name}, CaseName:{caseName}, AssignCount:{assignCount}.");
                    return operationId;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Assign files to labelers for relabeled.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="caseName">The label case name.</param>
        /// <param name="sameBatchLabelCaseId">The same batch label case id.</param>
        /// <param name="assignedLabelCaseId">The assigned label case id.</param>
        /// <returns>The assign operation id.</returns>
        public async Task<long> AssignRelabelCaseAsync(long sessionId, string caseName, long sameBatchLabelCaseId, long assignedLabelCaseId, EntityBase imageBatch)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();
                    var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(imageBatch.Id, caseName);
                    if (imageCase != null)
                    {
                        throw new InvalidOperationException("DuplicateName");
                    }

                    #region Get AssignLabelCaseGroup & Files

                    var sourceAssignedLabelCase = await caseDataManager.GetAssignedLabelCaseAsync(assignedLabelCaseId);
                    var sourceAssignedLabelCaseGroups = await caseDataManager.GetReviewFailedAssignedLabelCaseGroupsAsync(assignedLabelCaseId);
                    var imageCategoryId = sourceAssignedLabelCase.ImageCategoryId;
                    var assignCount = new QuantityBase { Group = sourceAssignedLabelCaseGroups.Count };
                    if (assignCount.Group == 0)
                    {
                        throw new InvalidOperationException("NoRelabelImages");
                    }

                    var assignLabelCaseGroupModels = new List<AssignLabelCaseGroupModel>();
                    foreach (var group in sourceAssignedLabelCaseGroups)
                    {
                        var assignLabelCaseGroupModel = new AssignLabelCaseGroupModel
                        {
                            Group = group,
                        };
                        var assignedLabelCaseFiles = await caseDataManager.GetAssignedLabelCaseFilesByGroupIdAsync(group.Id);
                        if (assignedLabelCaseFiles != null)
                        {
                            assignLabelCaseGroupModel.Files = assignedLabelCaseFiles;
                        }
                        assignLabelCaseGroupModels.Add(assignLabelCaseGroupModel);
                        assignCount.File++;
                    }

                    #endregion Get AssignLabelCaseGroup & Files

                    #region Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile

                    #region Create SameBatchLabelCase

                    var operationId = IdCreator.CreateId();
                    long institutionId = 0;
                    var account = await accountDataManager.GetAccountAsync(sourceAssignedLabelCase.Labeler.Id);
                    if (account != null)
                    {
                        institutionId = account.InstitutionId;
                    }
                    var sourceSameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(sameBatchLabelCaseId);
                    var sameBatchLabelCase = new SameBatchLabelCase
                    {
                        Name = caseName,
                        Organization = sourceSameBatchLabelCase.Organization,
                        ImageCategoryId = sourceSameBatchLabelCase.ImageCategoryId,
                        ImageBatchId = sourceSameBatchLabelCase.ImageBatchId,
                        ImageCaseId = sourceSameBatchLabelCase.ImageCaseId,
                        Mode = sourceSameBatchLabelCase.Mode,
                        Type = sourceSameBatchLabelCase.Type,
                        VideoItem = sourceSameBatchLabelCase.VideoItem,
                        Condition = AssignCondition.ReviewedNoPass,
                        AssignCount = assignCount,
                        State = SameBatchLabelCaseState.LabelerAssigned,
                    };

                    #endregion Create SameBatchLabelCase

                    #region Create ImageCategory

                    var sourceImageCase = await imageCategoryDataManager.GetImageCaseBySameBatchLabelCaseIdAsync(sameBatchLabelCaseId);
                    imageCase = new ImageCategory
                    {
                        Name = caseName,
                        Level = CategoryLevel.SameBatchLabelCase,
                        Parent = new EntityBase { Id = sourceImageCase.Id, Name = sourceImageCase.Name },
                        OrganizationId = sourceAssignedLabelCase.OrganizationId,
                        LabelPackageContentId = sourceAssignedLabelCase.LabelPackageContentId,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                    };
                    imageCase.Labelers.Add(sourceAssignedLabelCase.Labeler);
                    imageCase.GroupItem.Quantity.Total = assignCount.Group;
                    imageCase.GroupItem.Quantity.UnLabeled = assignCount.Group;
                    imageCase.FileItem.Quantity.Total = assignCount.File;
                    imageCase.FileItem.Quantity.UnLabeled = assignCount.File;
                    await imageCategoryDataManager.CreateImageCategoryAsync(imageCase);
                    await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(sourceImageCase.Id, true);

                    #endregion Create ImageCategory

                    #region Create AssignedLabelCase

                    var assignedCaseCount = (int)await caseDataManager.GetAssignedLabelCaseCountAsync(sourceAssignedLabelCase.Labeler.Id);
                    var assignedLabelCase = new AssignedLabelCase()
                    {
                        Name = caseName,
                        Labeler = sourceAssignedLabelCase.Labeler,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                        OrganizationId = sourceAssignedLabelCase.OrganizationId,
                        ImageCategoryId = sourceAssignedLabelCase.ImageCategoryId,
                        ImageBatchId = sourceAssignedLabelCase.ImageBatchId,
                        ImageCaseId = imageCase.Id,
                        LabelPackageContentId = sourceAssignedLabelCase.LabelPackageContentId,
                        InstitutionId = institutionId,
                        Mode = sourceAssignedLabelCase.Mode,
                        Count = assignCount,
                        CaseIndex = assignedCaseCount,
                    };
                    await caseDataManager.CreateAssignedLabelCaseAsync(assignedLabelCase);

                    #endregion Create AssignedLabelCase

                    #region Create AssignedLabelCaseFile

                    for (var i = 0; i < assignCount.Group; i++)
                    {
                        var assignLabelCaseGroupModel = assignLabelCaseGroupModels[i];
                        var sourceGroup = assignLabelCaseGroupModel.Group;
                        var assignedLabelCaseGroup = new AssignedLabelCaseGroup
                        {
                            ImageCategoryId = imageCategoryId,
                            AssignedLabelCaseId = assignedLabelCase.Id,
                            UltrasoundGroupId = sourceGroup.UltrasoundGroupId,
                            Index = i,
                        };
                        await caseDataManager.CreateAssignedLabelCaseGroupAsync(assignedLabelCaseGroup);

                        foreach (var sourceFile in assignLabelCaseGroupModel.Files)
                        {
                            var assignedLabelCaseFile = new AssignedLabelCaseFile()
                            {
                                ImageCategoryId = assignedLabelCase.ImageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                UltrasoundFileId = sourceFile.UltrasoundFileId,
                                Index = sourceFile.Index,
                                IsLabeled = false,
                                IsVideo = sourceFile.IsVideo,
                                //ParentLabeledUltrasoundFileId = sourceAssignLabelCaseFile.LabeledUltrasoundFileId,
                                //TopLabeledUltrasoundFileId = sourceAssignLabelCaseFile.TopLabeledUltrasoundFileId > 0 ? sourceAssignLabelCaseFile.TopLabeledUltrasoundFileId : sourceAssignLabelCaseFile.LabeledUltrasoundFileId,
                            };
                            await caseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);

                            var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(sourceFile.UltrasoundFileId);
                            if (!ultrasoundFile.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                            {
                                ultrasoundFile.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                await ultrasoundFileDataManager.UpdateImageCaseInfosForUltrasoundFileAsync(ultrasoundFile.Id, ultrasoundFile.ImageCaseInfos);
                            }

                            var progress = (int)((double)i / assignCount.File * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }
                    }

                    #endregion Create AssignedLabelCaseFile

                    //Create SameBatchLabelCase
                    var labelerInfo = new SameBatchLabelerInfo
                    {
                        Id = sourceAssignedLabelCase.Labeler.Id,
                        Name = sourceAssignedLabelCase.Labeler.Name,
                        AssignedLabelCaseId = assignedLabelCase.Id,
                        InstitutionId = institutionId,
                        AssignCount = assignCount,
                        AssignRestCount = assignCount,
                    };
                    sameBatchLabelCase.Labelers.Add(labelerInfo);
                    sameBatchLabelCase.ImageCaseId = imageCase.Id;
                    await sameBatchLabelCaseDataManager.CreateSameBatchLabelCaseAsync(sameBatchLabelCase);

                    #endregion Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile

                    #region Create LabelerGroup

                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(labelerInfo.Id, institutionId, sourceAssignedLabelCase.ImageCategoryId);
                    if (labelerGroup == null)
                    {
                        labelerGroup = new LabelerGroup
                        {
                            Labeler = sourceAssignedLabelCase.Labeler,
                            ImageCategoryId = sourceAssignedLabelCase.ImageCategoryId,
                            OrganizationId = sourceAssignedLabelCase.OrganizationId,
                            LabelCaseQuantityItem = new AssignedCaseQuantityItem
                            {
                                Total = assignCount.File,
                                Remaining = assignCount.File,
                            },
                        };
                        await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                    }
                    else
                    {
                        labelerGroup.LabelCaseQuantityItem.Total += assignCount.File;
                        labelerGroup.LabelCaseQuantityItem.Remaining += assignCount.File;
                        await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                    }
                    #endregion

                    OperationManager.SetProgress(operationId, 100);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} assigned relabel files to Labeler:{labelerInfo.Name}, source AssignedLabelCase Id:{assignedLabelCaseId}, CaseName:{caseName}, AssignCount:{assignCount}.");
                    return operationId;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        ///  Assigned labeled files to reviewers.
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="sameBatchLabelCaseId"></param>
        /// <param name="reviewers">The labelers to review.</param>
        /// <returns></returns>
        public async Task<long> AssignReviewCaseAsync(long sessionId, long sameBatchLabelCaseId, List<EntityBase> reviewers, List<AssignReviewInfo> assignReviewInfos, bool isHideLabelerName, bool isHideReviewerName)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var reviewCaseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    var operationId = IdCreator.CreateId();
                    var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(sameBatchLabelCaseId);
                    var labelCaseIds = sameBatchLabelCase.Labelers.Select(x => x.AssignedLabelCaseId);

                    switch (sameBatchLabelCase.Type)
                    {
                        case AssignType.DuplicateAssign:
                            foreach (var reviewer in reviewers)
                            {
                                #region Create assigned review case

                                var imageCount = 0;
                                var caseIndex = 0;
                                var lastAssignedReviewCase = await reviewCaseDataManager.GetLastIndexAssignedReviewCaseAsync(reviewer.Id, sameBatchLabelCase.ImageCategoryId);
                                if (lastAssignedReviewCase == null)
                                {
                                    caseIndex = (int)await reviewCaseDataManager.GetAssignedReviewCaseCountAsync(reviewer.Id);
                                }
                                else
                                {
                                    caseIndex = lastAssignedReviewCase.CaseIndex + 1;
                                }
                                long institutionId = 0;
                                var account = await accountDataManager.GetAccountAsync(reviewer.Id);
                                if (account != null)
                                {
                                    institutionId = account.InstitutionId;
                                }
                                var assignedReviewCase = new AssignedReviewCase
                                {
                                    Name = sameBatchLabelCase.Name,
                                    Reviewer = reviewer,
                                    SameBatchLabelCaseId = sameBatchLabelCase.Id,
                                    OrganizationId = sameBatchLabelCase.Organization.Id,
                                    ImageCategoryId = sameBatchLabelCase.ImageCategoryId,
                                    InstitutionId = institutionId,
                                    Count = sameBatchLabelCase.AssignCount,
                                    CaseIndex = caseIndex,
                                };
                                await reviewCaseDataManager.CreateAssignedReviewCaseAsync(assignedReviewCase);

                                #endregion Create assigned review case

                                #region Update index to assigned review cases

                                await reviewCaseDataManager.AddAndReorderIndexToAssignedReviewCasesAsync(assignedReviewCase);

                                #endregion

                                //labeled case
                                var reviewCaseFiles = new List<AssignedReviewCaseFile>();
                                var assignedReviewCount = new QuantityBase();
                                var reviewCaseFileIndex = 0;
                                foreach (var labelCaseId in labelCaseIds)
                                {
                                    var assignedCase = await caseDataManager.GetAssignedLabelCaseAsync(labelCaseId);
                                    if (assignedCase.QuestionedState > RelabelState.None)
                                    {
                                        assignedReviewCase.QuestionedState = RelabelState.ReviewerAssigned;
                                        await reviewCaseDataManager.UpdateAssignedReviewCaseQuestionedStateAsync(assignedReviewCase.Id, assignedReviewCase.QuestionedState);
                                    }

                                    //labeled case group
                                    var assignLabelCaseGroupModels = new List<AssignLabelCaseGroupModel>();
                                    var assignedLabelCaseGroups = await caseDataManager.GetAssignedLabelCaseGroupsByCaseIdAsync(assignedCase.Id);
                                    foreach (var group in assignedLabelCaseGroups)
                                    {
                                        var assignLabelCaseGroupModel = new AssignLabelCaseGroupModel
                                        {
                                            Group = group,
                                        };
                                        var assignedLabelCaseFiles = await caseDataManager.GetAssignedLabelCaseFilesByGroupIdAsync(group.Id);
                                        if (assignedLabelCaseFiles != null)
                                        {
                                            assignLabelCaseGroupModel.Files = assignedLabelCaseFiles;
                                        }
                                        assignLabelCaseGroupModels.Add(assignLabelCaseGroupModel);
                                    }

                                    //labeled case file.
                                    var labelCaseFiles = await caseDataManager.GetAssignedLabelCaseFilesByCaseIdAsync(assignedCase.Id);
                                    foreach (var labelCaseFile in labelCaseFiles)
                                    {
                                        #region Get assigned review case file

                                        var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(labelCaseFile.LabeledUltrasoundFileIds.LastOrDefault().Key);
                                        var labeledItem = new LabeledItem
                                        {
                                            Labeler = assignedCase.Labeler,
                                            AssignedLabelCaseId = labelCaseId,
                                            AssignedLabelCaseFileId = labelCaseFile.Id,
                                            IsSkipped = labelCaseFile.IsSkipped,
                                        };
                                        if (labelCaseFile.QuestionedState > RelabelState.None)
                                        {
                                            labeledItem.QuestionedState = RelabelState.ReviewerAssigned;
                                        }
                                        labeledItem.LabeledUltrasoundFileInfos.Add(new LabeledFileInfo
                                        {
                                            CreateTime = labeledUltrasoundFile.CreateTime,
                                            LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                                            IsSkipped = labeledUltrasoundFile.IsSkipped,
                                        });
                                        var reviewCaseFile = reviewCaseFiles.FirstOrDefault(x => x.AssignedReviewCaseId == assignedReviewCase.Id && x.Index == labelCaseFile.Index);
                                        if (reviewCaseFile == null)
                                        {
                                            reviewCaseFile = new AssignedReviewCaseFile()
                                            {
                                                AssignedReviewCaseId = assignedReviewCase.Id,
                                                ImageCategoryId = assignedReviewCase.ImageCategoryId,
                                                Index = reviewCaseFileIndex,
                                                IsVideo = labelCaseFile.IsVideo,
                                            };
                                            if (labelCaseFile.QuestionedState > RelabelState.None)
                                            {
                                                reviewCaseFile.QuestionedState = RelabelState.ReviewerAssigned;
                                            }
                                            reviewCaseFile.LabeledItems.Add(labeledItem);
                                            reviewCaseFiles.Add(reviewCaseFile);
                                            reviewCaseFileIndex++;
                                        }
                                        else
                                        {
                                            reviewCaseFile.LabeledItems.Add(labeledItem);
                                        }

                                        #endregion Get assigned review case file

                                        if (assignedCase.RelabelState == RelabelState.LabelerAssigned && labeledUltrasoundFile.DeveloperItem.QuestionedState == QuestionedState.Assigned && (labelCaseFile.RelabelState == RelabelState.LabelerAssigned || labelCaseFile.QuestionedState == RelabelState.LabelerAssigned))
                                        {
                                            await caseDataManager.UpdateAssignedLabelCaseRelabelStateAsync(assignedCase.Id, RelabelState.None);
                                        }

                                        assignedReviewCount.File++;
                                    }
                                }

                                #region Create assigned review case file

                                foreach (var reviewCaseFile in reviewCaseFiles)
                                {
                                    await reviewCaseDataManager.CreateAssignedReviewCaseFileAsync(reviewCaseFile);
                                    //Update review state in labeled ultrasound file.
                                    foreach (var labeledItem in reviewCaseFile.LabeledItems)
                                    {
                                        await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileReviewStateAsync(labeledItem.LabeledUltrasoundFileInfos.LastOrDefault().LabeledUltrasoundFileId, ReviewState.Assigned);
                                    }
                                    imageCount++;
                                    var progress = (int)((double)imageCount / reviewCaseFiles.Count() * 100);
                                    OperationManager.SetProgress(operationId, progress);
                                }
                                #endregion

                                #region Create LabelerGroup

                                var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(reviewer.Id, institutionId, sameBatchLabelCase.ImageCategoryId);
                                if (labelerGroup == null)
                                {
                                    labelerGroup = new LabelerGroup
                                    {
                                        Labeler = new EntityBase { Id = reviewer.Id, Name = reviewer.Name },
                                        ImageCategoryId = sameBatchLabelCase.ImageCategoryId,
                                        OrganizationId = sameBatchLabelCase.Organization.Id,
                                        ReviewCaseQuantityItem = new AssignedCaseQuantityItem
                                        {
                                            Total = assignedReviewCount.File,
                                            Remaining = assignedReviewCount.File,
                                        },
                                    };
                                    await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                                }
                                else
                                {
                                    labelerGroup.ReviewCaseQuantityItem.Total += assignedReviewCount.File;
                                    labelerGroup.ReviewCaseQuantityItem.Remaining += assignedReviewCount.File;
                                    await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                                }
                                #endregion

                                sameBatchLabelCase.Reviewers.Add(new SameBatchReviewerInfo
                                {
                                    Id = reviewer.Id,
                                    Name = reviewer.Name,
                                    State = ReviewState.Assigned,
                                    AssignedReviewCaseId = assignedReviewCase.Id,
                                    InstitutionId = institutionId,
                                    AssignCount = assignedReviewCount,
                                });
                            }
                            break;
                        case AssignType.AverageAssign:
                            foreach (var assignReviewInfo in assignReviewInfos)
                            {
                                #region Create assigned review case

                                var imageCount = 0;
                                var caseIndex = 0;
                                var lastAssignedReviewCase = await reviewCaseDataManager.GetLastIndexAssignedReviewCaseAsync(assignReviewInfo.Reviewer.Id, sameBatchLabelCase.ImageCategoryId);
                                if (lastAssignedReviewCase == null)
                                {
                                    caseIndex = (int)await reviewCaseDataManager.GetAssignedReviewCaseCountAsync(assignReviewInfo.Reviewer.Id);
                                }
                                else
                                {
                                    caseIndex = lastAssignedReviewCase.CaseIndex + 1;
                                }
                                long institutionId = 0;
                                var account = await accountDataManager.GetAccountAsync(assignReviewInfo.Reviewer.Id);
                                if (account != null)
                                {
                                    institutionId = account.InstitutionId;
                                }
                                var assignedReviewCase = new AssignedReviewCase
                                {
                                    Name = sameBatchLabelCase.Name,
                                    Reviewer = assignReviewInfo.Reviewer,
                                    SameBatchLabelCaseId = sameBatchLabelCase.Id,
                                    OrganizationId = sameBatchLabelCase.Organization.Id,
                                    ImageCategoryId = sameBatchLabelCase.ImageCategoryId,
                                    InstitutionId = institutionId,
                                    Count = assignReviewInfo.AssignLabelCount,
                                    CaseIndex = caseIndex,
                                };
                                await reviewCaseDataManager.CreateAssignedReviewCaseAsync(assignedReviewCase);

                                #endregion Create assigned review case

                                #region Update index to assigned review cases

                                await reviewCaseDataManager.AddAndReorderIndexToAssignedReviewCasesAsync(assignedReviewCase);

                                #endregion

                                //labeled case
                                var reviewCaseFiles = new List<AssignedReviewCaseFile>();
                                var assignedReviewCount = new QuantityBase();
                                var reviewCaseFileIndex = 0;
                                var assignedCase = await caseDataManager.GetAssignedLabelCaseAsync(assignReviewInfo.AssignedLabelCaseId);
                                //labeled case file.
                                var labelCaseFiles = await caseDataManager.GetAssignedLabelCaseFilesByCaseIdAsync(assignedCase.Id);
                                foreach (var labelCaseFile in labelCaseFiles)
                                {
                                    #region Get assigned review case file

                                    var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(labelCaseFile.LabeledUltrasoundFileIds.LastOrDefault().Key);
                                    var labeledItem = new LabeledItem
                                    {
                                        Labeler = assignedCase.Labeler,
                                        AssignedLabelCaseId = assignedCase.Id,
                                        AssignedLabelCaseFileId = labelCaseFile.Id,
                                        IsSkipped = labelCaseFile.IsSkipped,
                                    };
                                    labeledItem.LabeledUltrasoundFileInfos.Add(new LabeledFileInfo
                                    {
                                        CreateTime = labeledUltrasoundFile.CreateTime,
                                        LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                                        IsSkipped = labeledUltrasoundFile.IsSkipped,
                                    });
                                    var reviewCaseFile = reviewCaseFiles.FirstOrDefault(x => x.AssignedReviewCaseId == assignedReviewCase.Id && x.Index == labelCaseFile.Index);
                                    if (reviewCaseFile == null)
                                    {
                                        reviewCaseFile = new AssignedReviewCaseFile()
                                        {
                                            AssignedReviewCaseId = assignedReviewCase.Id,
                                            ImageCategoryId = assignedReviewCase.ImageCategoryId,
                                            Index = reviewCaseFileIndex,
                                            IsVideo = labelCaseFile.IsVideo,
                                        };
                                        reviewCaseFile.LabeledItems.Add(labeledItem);
                                        reviewCaseFiles.Add(reviewCaseFile);
                                        reviewCaseFileIndex++;
                                    }
                                    else
                                    {
                                        reviewCaseFile.LabeledItems.Add(labeledItem);
                                    }

                                    #endregion Get assigned review case file

                                    assignedReviewCount.File++;
                                }

                                #region Create assigned review case file

                                foreach (var reviewCaseFile in reviewCaseFiles)
                                {
                                    await reviewCaseDataManager.CreateAssignedReviewCaseFileAsync(reviewCaseFile);
                                    //Update review state in labeled ultrasound file.
                                    foreach (var labeledItem in reviewCaseFile.LabeledItems)
                                    {
                                        await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileReviewStateAsync(labeledItem.LabeledUltrasoundFileInfos.LastOrDefault().LabeledUltrasoundFileId, ReviewState.Assigned);
                                    }
                                    imageCount++;
                                    var progress = (int)((double)imageCount / reviewCaseFiles.Count() * 100);
                                    OperationManager.SetProgress(operationId, progress);
                                }
                                #endregion

                                #region Create LabelerGroup

                                var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(assignReviewInfo.Reviewer.Id, institutionId, sameBatchLabelCase.ImageCategoryId);
                                if (labelerGroup == null)
                                {
                                    labelerGroup = new LabelerGroup
                                    {
                                        Labeler = assignReviewInfo.Reviewer,
                                        ImageCategoryId = sameBatchLabelCase.ImageCategoryId,
                                        OrganizationId = sameBatchLabelCase.Organization.Id,
                                        ReviewCaseQuantityItem = new AssignedCaseQuantityItem
                                        {
                                            Total = assignedReviewCount.File,
                                            Remaining = assignedReviewCount.File,
                                        },
                                    };
                                    await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                                }
                                else
                                {
                                    labelerGroup.ReviewCaseQuantityItem.Total += assignedReviewCount.File;
                                    labelerGroup.ReviewCaseQuantityItem.Remaining += assignedReviewCount.File;
                                    await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                                }
                                #endregion

                                sameBatchLabelCase.Reviewers.Add(new SameBatchReviewerInfo
                                {
                                    Id = assignReviewInfo.Reviewer.Id,
                                    Name = assignReviewInfo.Reviewer.Name,
                                    State = ReviewState.Assigned,
                                    AssignedReviewCaseId = assignedReviewCase.Id,
                                    InstitutionId = institutionId,
                                    AssignCount = assignedReviewCount,
                                });
                            }
                            break;
                        default:
                            break;
                    }

                    sameBatchLabelCase.State = SameBatchLabelCaseState.ReviewerAssigned;
                    sameBatchLabelCase.IsHideLabelerName = isHideLabelerName;
                    sameBatchLabelCase.IsHideReviewerName = isHideReviewerName;
                    await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);

                    OperationManager.SetProgress(operationId, 100);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} assigned labeled files to reviewers:[{string.Join(',', reviewers)}], CaseName:{sameBatchLabelCase.Name}.");
                    return operationId;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        public async Task<long> AssignQuestionedFilesEachAsync(long sessionId, EntityBase organization, long imageCategoryId, long imageBatchId, List<EntityBase> labelers, List<AssignQuestionCaseViewModel> assignQuestionCaseViews)
        {
            var operationId = IdCreator.CreateId();
            var i = 0;
            foreach (var item in assignQuestionCaseViews)
            {
                var isSelf = false;
                if (item.Assign_Id == item.Question_Id)
                {
                    isSelf = true;
                }
                var questionLabeler = labelers.Where(x => x.Id == item.Question_Id).FirstOrDefault();
                var assignLabeler = labelers.Where(x => x.Id == item.Assign_Id).FirstOrDefault();
                await AssignQuestionedFilesAsync(sessionId, item.NewCase_Name, organization, imageCategoryId, imageBatchId, item.Question_Id, assignLabeler, isSelf, item.Hidden_Auditor, item.assignedLabelCaseIds);
                i++;
                var progress = (int)((double)i / assignQuestionCaseViews.Count * 100);
                OperationManager.SetProgress(operationId, progress);
            }
            OperationManager.SetProgress(operationId, 100);
            return operationId;
        }
        /// <summary>
        /// Assign questioned label files to labeler.
        /// </summary>
        /// <param name="caseName">The label case name.</param>
        /// <param name="organization">The organization of label case.</param>
        /// <param name="imageCategoryId">The image category id.</param>
        /// <returns>The assign operation id.</returns>
        private async Task<long> AssignQuestionedFilesAsync(long sessionId, string caseName, EntityBase organization, long imageCategoryId, long imageBatchId, long questionedLabelerId, EntityBase assignedLabeler, bool isSelf, bool isHideReviewerName, List<long> assignedLabelCaseIds)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var assignedLabeelCaseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var developerFolderDataManager = databaseService.GetManager<IDeveloperFolderDataManager>();
                    var developerLabeledUltrasoundFileDataManager = databaseService.GetManager<IDeveloperLabeledUltrasoundFileDataManager>();
                    var reLabelRecordDataManager = databaseService.GetManager<IReLabelRecordDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    if (!isSelf)
                    {
                        var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(imageBatchId, caseName);
                        if (imageCase != null)
                        {
                            throw new InvalidOperationException("DuplicateName");
                        }
                    }

                    var labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetQuestionedLabeledUltrasoundFilesWithoutIsRelabelAsync(CategoryLevel.Batch, imageBatchId, questionedLabelerId, QuestionedState.PendingAssigned, assignedLabelCaseIds);
                    if (labeledUltrasoundFiles.Count == 0)
                    {
                        throw new InvalidOperationException("NoQuestionedFiles");
                    }

                    var operationId = IdCreator.CreateId();
                    var ultrasoundGroupIds = labeledUltrasoundFiles.Select(x => x.UltrasoundGroupId).Distinct().ToList();
                    var ultrasoundFileIds = labeledUltrasoundFiles.Select(x => x.UltrasoundFileId).Distinct().ToList();
                    var assignCount = new QuantityBase { Group = ultrasoundGroupIds.Count, File = ultrasoundFileIds.Count };
                    var assignUltrasoundModels = new List<AssignUltrasoundModel>();
                    var modalItems = new List<ModalQuantityItem>();
                    foreach (var ultrasoundGroupId in ultrasoundGroupIds)
                    {
                        var group = await ultrasoundGroupDataManager.GetUltrasoundGroupAsync(ultrasoundGroupId);
                        var assignUltrasoundModel = new AssignUltrasoundModel
                        {
                            Group = group,
                        };
                        var ultrasoundFiles = await ultrasoundFileDataManager.GetUltrasoundFilesExcludePreviewImageAsync(ultrasoundGroupId);
                        if (ultrasoundFiles != null)
                        {
                            assignUltrasoundModel.Files = ultrasoundFiles;
                            foreach (var ultrasoundFile in ultrasoundFiles)
                            {
                                var modalItem = modalItems.FirstOrDefault(x => x.Modal.Id == ultrasoundFile.Modal.Id || x.Modal.Title == ultrasoundFile.Modal.Title);
                                if (modalItem == null)
                                {
                                    modalItem = new ModalQuantityItem
                                    {
                                        Modal = ultrasoundFile.Modal,
                                    };
                                    modalItems.Add(modalItem);
                                }
                                modalItem.Quantity.Total++;
                                modalItem.Quantity.UnLabeled++;
                            }
                        }
                        assignUltrasoundModels.Add(assignUltrasoundModel);
                    }

                    if (isSelf)
                    {
                        var i = 0;
                        var assignedLabelCases = new List<AssignedLabelCase>();
                        foreach (var labeledUltrasoundFile in labeledUltrasoundFiles)
                        {
                            #region Update AssignedLabelCaseFile

                            var assignedLabelCaseFile = await assignedLabeelCaseDataManager.GetAssignedLabelCaseFileByLabeledUltrasoundFileIdAsync(labeledUltrasoundFile.Id);
                            assignedLabelCaseFile.SourceLabeledUltrasoundFileId = labeledUltrasoundFile.Id;
                            if (assignedLabelCaseFile.RelabelState == RelabelState.None || assignedLabelCaseFile.RelabelState == RelabelState.LabelerCompleted || assignedLabelCaseFile.RelabelState == RelabelState.ReviewerCompleted)
                            {
                                assignedLabelCaseFile.RelabelState = RelabelState.LabelerAssigned;
                                assignedLabelCaseFile.IsReviewFailed = true;
                            }
                            if (assignedLabelCaseFile.QuestionedState == RelabelState.None || assignedLabelCaseFile.QuestionedState == RelabelState.LabelerCompleted || assignedLabelCaseFile.QuestionedState == RelabelState.ReviewerCompleted)
                            {
                                assignedLabelCaseFile.QuestionedState = RelabelState.LabelerAssigned;
                            }
                            await assignedLabeelCaseDataManager.UpdateAssignedLabelCaseFileAsync(assignedLabelCaseFile);

                            #endregion

                            #region Update AssignedLabelCaseGroup

                            var isUpdateAssignedLabelCaseGroup = false;
                            var assignedLabelCaseGroup = await assignedLabeelCaseDataManager.GetAssignedLabelCaseGroupByCaseIdAndUltrasoundGroupIdAsync(assignedLabelCaseFile.AssignedLabelCaseId, assignedLabelCaseFile.AssignedLabelCaseGroupId);
                            if (assignedLabelCaseGroup != null && assignedLabelCaseGroup.RelabelState != assignedLabelCaseFile.RelabelState && assignedLabelCaseGroup.QuestionedState != assignedLabelCaseFile.QuestionedState)
                            {
                                assignedLabelCaseGroup.RelabelState = assignedLabelCaseFile.RelabelState;
                                assignedLabelCaseGroup.QuestionedState = assignedLabelCaseFile.QuestionedState;
                                isUpdateAssignedLabelCaseGroup = true;
                            }
                            if (isUpdateAssignedLabelCaseGroup)
                            {
                                await assignedLabeelCaseDataManager.UpdateAssignedLabelCaseGroupAsync(assignedLabelCaseGroup);
                            }

                            #endregion

                            if (!assignedLabelCases.Any(x => x.Id == assignedLabelCaseFile.AssignedLabelCaseId))
                            {
                                var assignedLabelCase = await assignedLabeelCaseDataManager.GetAssignedLabelCaseAsync(assignedLabelCaseFile.AssignedLabelCaseId);
                                if (assignedLabelCase.RelabelState == RelabelState.None || assignedLabelCase.RelabelState == RelabelState.LabelerCompleted)
                                {
                                    assignedLabelCase.RelabelState = RelabelState.LabelerAssigned;
                                    await assignedLabeelCaseDataManager.UpdateAssignCaseAsync(assignedLabelCase);
                                }
                                assignedLabelCases.Add(assignedLabelCase);

                                var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(assignedLabelCase.SameBatchLabelCaseId);
                                sameBatchLabelCase.IsHideReviewerName = isHideReviewerName;
                                await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
                            }

                            labeledUltrasoundFile.DeveloperItem.QuestionedState = QuestionedState.Assigned;
                            await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileDeveloperItemAsync(labeledUltrasoundFile.Id, labeledUltrasoundFile.DeveloperItem);
                            labeledUltrasoundFile.IsQuestion = true;
                            await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileIsQuestionAsync(labeledUltrasoundFile.Id, true);

                            #region Update ImageCase

                            var isUpdateImageCase = false;
                            var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(labeledUltrasoundFile.ImageCaseId);
                            var detail = imageCase.FileItem.QuestionedQuantityDetails.FirstOrDefault(x => x.Labeler.Id == questionedLabelerId);
                            if (detail != null)
                            {
                                detail.UnAssigned--;
                                imageCase.FileItem.QuestionedQuantity.UnAssigned--;
                                isUpdateImageCase = true;
                            }
                            if (isUpdateAssignedLabelCaseGroup)
                            {
                                var detail2 = imageCase.GroupItem.QuestionedQuantityDetails.FirstOrDefault(x => x.Labeler.Id == questionedLabelerId);
                                if (detail2 != null)
                                {
                                    detail2.UnAssigned--;
                                    imageCase.GroupItem.QuestionedQuantity.UnAssigned--;
                                    isUpdateImageCase = true;
                                }
                            }
                            if (isUpdateImageCase)
                            {
                                await imageCategoryDataManager.UpdateImageCategoryAsync(imageCase);
                            }

                            #endregion

                            #region Update developerLabeledUltrasoundFile & developerFolderFile

                            var developerFolderFiles = await developerFolderDataManager.GetDeveloperFolderFilesAsync(labeledUltrasoundFile.Id);
                            foreach (var developerFolderFile in developerFolderFiles)
                            {
                                var developerLabeledUltrasoundInfo = developerFolderFile.DeveloperLabeledUltrasoundInfoList.FirstOrDefault(x => x.LabeledUltrasoundFileId == labeledUltrasoundFile.Id && x.DeveloperItem.QuestionedState != QuestionedState.Assigned);
                                if (developerLabeledUltrasoundInfo != null)
                                {
                                    developerLabeledUltrasoundInfo.DeveloperItem.QuestionedState = QuestionedState.Assigned;
                                    await developerLabeledUltrasoundFileDataManager.UpdateDeveloperLabeledUltrasoundFileDeveloperItemAsync(developerLabeledUltrasoundInfo.DeveloperLabeledUltrasoundFileId, developerLabeledUltrasoundInfo.DeveloperItem);
                                    await developerFolderDataManager.UpdateDeveloperFolderFileAsync(developerFolderFile);
                                }
                                var devFolderGroup = await developerFolderDataManager.GetDeveloperFolderGroupAsync(developerFolderFile.DeveloperFolderGroupId);
                                if (devFolderGroup != null)
                                {
                                    if (!devFolderGroup.HasQuestioned)
                                    {
                                        devFolderGroup.HasQuestioned = true;
                                        await developerFolderDataManager.UpdateDeveloperFolderGroupAsync(devFolderGroup);
                                    }
                                }
                            }

                            #endregion

                            #region Create Question ReLabelRecord

                            var reLabelRecordData = await reLabelRecordDataManager.GetReLabelRecordByAssignedLabelCaseIdAsync(labeledUltrasoundFile.AssignedLabelCaseId, true);
                            if (reLabelRecordData != null)
                            {
                                var reLabelRecor = reLabelRecordData;
                                var reLabelRecordCounts = reLabelRecor.ReLabelRecordCounts.FirstOrDefault();
                                reLabelRecordCounts.NoPassCount += 1;
                                reLabelRecordCounts.NoPassLabeledUltrasoundFileIds.Add(new NoPassLabledInfo
                                {
                                    IsAccomplishLable = false,
                                    IsAccomplishReview = false,
                                    LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                                    UltrasoundFileId = labeledUltrasoundFile.UltrasoundFileId
                                });
                                await reLabelRecordDataManager.UpdateReLabelRecordAsync(reLabelRecor);
                            }
                            else
                            {
                                ReLabelRecord reLabelRecord = new ReLabelRecord();
                                reLabelRecord.SourceAssignedLabelCaseId = labeledUltrasoundFile.AssignedLabelCaseId;

                                var assignedLableCaseData = await assignedLabeelCaseDataManager.GetAssignedLabelCaseAsync(labeledUltrasoundFile.AssignedLabelCaseId);
                                reLabelRecord.SourceSameBatchLabelCaseId = assignedLableCaseData.SameBatchLabelCaseId;
                                reLabelRecord.Labeler = labeledUltrasoundFile.Labeler;
                                reLabelRecord.IsQuestion = true;
                                reLabelRecord.IsAssign = false;
                                reLabelRecord.AssignInfo = new AssignInfo();
                                var fileresultinfo = labeledUltrasoundFile.FileResultInfos.FirstOrDefault();
                                var reviewer = new EntityBase();
                                if (fileresultinfo != null)
                                {

                                    if (fileresultinfo.ReviewedInfos.Count > 1)
                                    {
                                        reviewer = fileresultinfo.ReviewedInfos[fileresultinfo.ReviewedInfos.Count - 1].Reviewer;
                                    }
                                    else if (fileresultinfo.ReviewedInfos.Count == 1)
                                    {
                                        reviewer = fileresultinfo.ReviewedInfos.LastOrDefault().Reviewer;
                                    }
                                }
                                reLabelRecord.ReLabelRecordCounts = new List<ReLabelRecordCount>()
                                {
                                    new ReLabelRecordCount()
                                    {
                                        ReLableDateTime = DateTime.UtcNow,
                                        Id = IdCreator.CreateId(),
                                        IsLock = true,
                                        NoPassCount = 1,
                                        NoPassLabeledUltrasoundFileIds = new List<NoPassLabledInfo>()
                                        {
                                            new NoPassLabledInfo
                                            {
                                                IsAccomplishLable = false,
                                                IsAccomplishReview = false,
                                                LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                                                UltrasoundFileId = labeledUltrasoundFile.UltrasoundFileId
                                            }
                                        },
                                        ReLabelCount = 0,
                                        ReLableReviewInfos = new List<ReLableReviewInfo>()
                                        {
                                            new ReLableReviewInfo()
                                            {
                                                ReviewCount = 0,
                                                IsCurrent = true,
                                                Reviewer = reviewer
                                            }
                                        }
                                    }
                                };

                                await reLabelRecordDataManager.CreateReLabelRecordAsync(reLabelRecord);
                            }


                            #endregion

                            i++;
                            var progress = (int)((double)i / assignCount.File * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }
                    }
                    else
                    {
                        #region Create SameBatchLabelCase & ImageCase & AssignedLabelCase & AssignedLabelCaseFile

                        #region Create SameBatchLabelCase

                        var sameBatchLabelCase = new SameBatchLabelCase
                        {
                            Name = caseName,
                            Organization = organization,
                            ImageCategoryId = imageCategoryId,
                            ImageBatchId = imageBatchId,
                            Condition = AssignCondition.DeveloperQuestioned,
                            AssignCount = assignCount,
                            State = SameBatchLabelCaseState.LabelerAssigned,
                            IsHideReviewerName = isHideReviewerName,
                        };

                        #endregion Create SameBatchLabelCase

                        #region Create ImageCase

                        var imageCase = new ImageCategory
                        {
                            Name = caseName,
                            Level = CategoryLevel.SameBatchLabelCase,
                            Parent = new EntityBase { Id = imageBatch.Id, Name = imageBatch.Name },
                            OrganizationId = organization.Id,
                            LabelPackageContentId = imageBatch.LabelPackageContentId,
                            SameBatchLabelCaseId = sameBatchLabelCase.Id,
                        };
                        imageCase.Labelers.Add(assignedLabeler);
                        imageCase.GroupItem.Quantity.Total = assignCount.Group;
                        imageCase.GroupItem.Quantity.UnLabeled = assignCount.Group;
                        imageCase.FileItem.Quantity.Total = assignCount.File;
                        imageCase.FileItem.Quantity.UnLabeled = assignCount.File;
                        imageCase.ModalItems = modalItems;
                        await imageCategoryDataManager.CreateImageCategoryAsync(imageCase);
                        if (!imageBatch.HasChildren)
                        {
                            await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(imageBatch.Id, true);
                        }

                        #endregion Create ImageCase

                        #region Create AssignedLabelCase

                        var caseIndex = 0;
                        var lastAssignedCase = await assignedLabeelCaseDataManager.GetLastIndexAssignedLabelCaseAsync(assignedLabeler.Id, imageCategoryId);
                        if (lastAssignedCase == null)
                        {
                            caseIndex = (int)await assignedLabeelCaseDataManager.GetAssignedLabelCaseCountAsync(assignedLabeler.Id);
                        }
                        else
                        {
                            caseIndex = lastAssignedCase.CaseIndex + 1;
                        }
                        long institutionId = 0;
                        var account = await accountDataManager.GetAccountAsync(assignedLabeler.Id);
                        if (account != null)
                        {
                            institutionId = account.InstitutionId;
                        }
                        var assignedLabelCase = new AssignedLabelCase
                        {
                            Name = caseName,
                            Labeler = assignedLabeler,
                            SameBatchLabelCaseId = sameBatchLabelCase.Id,
                            OrganizationId = organization.Id,
                            ImageCategoryId = imageCategoryId,
                            ImageBatchId = imageBatchId,
                            ImageCaseId = imageCase.Id,
                            LabelPackageContentId = imageBatch.LabelPackageContentId,
                            Count = assignCount,
                            CaseIndex = caseIndex,
                            QuestionedState = RelabelState.LabelerAssigned,
                        };
                        await assignedLabeelCaseDataManager.CreateAssignedLabelCaseAsync(assignedLabelCase);
                        await assignedLabeelCaseDataManager.AddAndReorderIndexToAssignedLabelCasesAsync(assignedLabelCase);

                        #endregion Create AssignedLabelCase

                        #region Create AssignedLabelCaseFile

                        for (var i = 0; i < assignCount.Group; i++)
                        {
                            var ultrasoundGroupId = ultrasoundGroupIds[i];
                            var assignedLabelCaseGroup = new AssignedLabelCaseGroup
                            {
                                ImageCategoryId = imageCategoryId,
                                AssignedLabelCaseId = assignedLabelCase.Id,
                                UltrasoundGroupId = ultrasoundGroupId,
                                Index = i,
                                QuestionedState = RelabelState.LabelerAssigned,
                                IsReviewFailed = true,
                            };
                            await assignedLabeelCaseDataManager.CreateAssignedLabelCaseGroupAsync(assignedLabelCaseGroup);

                            #region Update UltrasoundGroup

                            var ultrasoundGroup = await ultrasoundGroupDataManager.GetUltrasoundGroupAsync(ultrasoundGroupId);
                            if (ultrasoundGroup != null)
                            {
                                ultrasoundGroup.ImageCaseInfos ??= new List<ImageCaseInfo>();
                                if (!ultrasoundGroup.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                                {
                                    ultrasoundGroup.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                    await ultrasoundGroupDataManager.UpdateUltrasoundGroupAsync(ultrasoundGroup);
                                }
                            }

                            #endregion

                            var ultrasoundFiles = await ultrasoundFileDataManager.GetUltrasoundFilesExcludePreviewImageAsync(ultrasoundGroupId);
                            foreach (var ultrasoundFile in ultrasoundFiles)
                            {
                                var assignedLabelCaseFile = new AssignedLabelCaseFile
                                {
                                    ImageCategoryId = assignedLabelCase.ImageCategoryId,
                                    AssignedLabelCaseId = assignedLabelCase.Id,
                                    UltrasoundFileId = ultrasoundFile.Id,
                                    Index = ultrasoundFile.Index,
                                    IsLabeled = false,
                                    IsVideo = ultrasoundFile.IsVideo,
                                };
                                var labeledUltrasoundFile = labeledUltrasoundFiles.FirstOrDefault(x => x.UltrasoundFileId == ultrasoundFile.Id);
                                if (labeledUltrasoundFile != null)
                                {
                                    assignedLabelCaseFile.SourceLabeledUltrasoundFileId = labeledUltrasoundFile.Id;
                                    assignedLabelCaseFile.QuestionedState = RelabelState.LabelerAssigned;
                                }
                                await assignedLabeelCaseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);

                                if (!ultrasoundFile.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                                {
                                    ultrasoundFile.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                                    await ultrasoundFileDataManager.UpdateImageCaseInfosForUltrasoundFileAsync(ultrasoundFile.Id, ultrasoundFile.ImageCaseInfos);
                                }

                                if (labeledUltrasoundFile != null)
                                {
                                    labeledUltrasoundFile.DeveloperItem.QuestionedState = QuestionedState.Assigned;
                                    await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileDeveloperItemAsync(labeledUltrasoundFile.Id, labeledUltrasoundFile.DeveloperItem);

                                    #region Update Source ImageCase

                                    var sourceImageCase = await imageCategoryDataManager.GetImageCategoryAsync(labeledUltrasoundFile.ImageCaseId);
                                    var detail = sourceImageCase.FileItem.QuestionedQuantityDetails.FirstOrDefault(x => x.Labeler.Id == questionedLabelerId);
                                    if (detail != null)
                                    {
                                        var count = labeledUltrasoundFiles.Where(x => x.UltrasoundFileId == ultrasoundFile.Id).Count();
                                        detail.UnAssigned -= count;
                                        sourceImageCase.FileItem.QuestionedQuantity.UnAssigned -= count;
                                        await imageCategoryDataManager.UpdateImageCategoryAsync(sourceImageCase);
                                    }

                                    #endregion

                                    #region Update developerLabeledUltrasoundFile & developerFolderFile

                                    var developerFolderFiles = await developerFolderDataManager.GetDeveloperFolderFilesAsync(labeledUltrasoundFile.Id);
                                    foreach (var developerFolderFile in developerFolderFiles)
                                    {
                                        var developerLabeledUltrasoundInfo = developerFolderFile.DeveloperLabeledUltrasoundInfoList.FirstOrDefault(x => x.LabeledUltrasoundFileId == labeledUltrasoundFile.Id && x.DeveloperItem.QuestionedState != QuestionedState.Assigned);
                                        if (developerLabeledUltrasoundInfo != null)
                                        {
                                            developerLabeledUltrasoundInfo.DeveloperItem.QuestionedState = QuestionedState.Assigned;
                                            await developerLabeledUltrasoundFileDataManager.UpdateDeveloperLabeledUltrasoundFileDeveloperItemAsync(developerLabeledUltrasoundInfo.DeveloperLabeledUltrasoundFileId, developerLabeledUltrasoundInfo.DeveloperItem);
                                            await developerFolderDataManager.UpdateDeveloperFolderFileAsync(developerFolderFile);
                                        }
                                        var devFolderGroup = await developerFolderDataManager.GetDeveloperFolderGroupAsync(developerFolderFile.DeveloperFolderGroupId);
                                        if (devFolderGroup != null)
                                        {
                                            if (!devFolderGroup.HasQuestioned)
                                            {
                                                devFolderGroup.HasQuestioned = true;
                                                await developerFolderDataManager.UpdateDeveloperFolderGroupAsync(devFolderGroup);
                                            }
                                        }
                                    }

                                    #endregion

                                    #region Create Question ReLabelRecord

                                    var reLabelRecordData = await reLabelRecordDataManager.GetReLabelRecordByAssignedLabelCaseIdAsync(labeledUltrasoundFile.AssignedLabelCaseId);
                                    if (reLabelRecordData != null && reLabelRecordData.Any(x => x.IsQuestion))
                                    {
                                        var reLabelRecor = reLabelRecordData.Where(x => x.IsQuestion).FirstOrDefault();
                                        var reLabelRecordCounts = reLabelRecor.ReLabelRecordCounts.FirstOrDefault();
                                        reLabelRecordCounts.NoPassCount += 1;
                                        reLabelRecordCounts.NoPassLabeledUltrasoundFileIds.Add(new NoPassLabledInfo
                                        {
                                            IsAccomplishLable = false,
                                            IsAccomplishReview = false,
                                            LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                                            UltrasoundFileId = labeledUltrasoundFile.UltrasoundFileId
                                        });
                                        reLabelRecor.AssignInfo.AssignCount += 1;
                                        await reLabelRecordDataManager.UpdateReLabelRecordAsync(reLabelRecor);
                                    }
                                    else
                                    {
                                        ReLabelRecord reLabelRecord = new ReLabelRecord();
                                        reLabelRecord.SourceAssignedLabelCaseId = labeledUltrasoundFile.AssignedLabelCaseId;

                                        var assignedLableCaseData = await assignedLabeelCaseDataManager.GetAssignedLabelCaseAsync(labeledUltrasoundFile.AssignedLabelCaseId);
                                        reLabelRecord.SourceSameBatchLabelCaseId = assignedLableCaseData.SameBatchLabelCaseId;
                                        reLabelRecord.Labeler = labeledUltrasoundFile.Labeler;
                                        reLabelRecord.IsQuestion = true;
                                        reLabelRecord.IsAssign = true;
                                        reLabelRecord.AssignInfo = new AssignInfo()
                                        {
                                            AssignCount = 1,
                                            Labeler = assignedLabeler,
                                            SameBatchLabelCase = new EntityBase { Id = sameBatchLabelCase.Id, Name = sameBatchLabelCase.Name },
                                        };
                                        reLabelRecord.ReLabelRecordCounts = new List<ReLabelRecordCount>()
                                        {
                                            new ReLabelRecordCount()
                                            {
                                                ReLableDateTime = DateTime.UtcNow,
                                                Id = IdCreator.CreateId(),
                                                IsLock = true,
                                                NoPassCount = 1,
                                                NoPassLabeledUltrasoundFileIds = new List<NoPassLabledInfo>()
                                                {
                                                    new NoPassLabledInfo
                                                    {
                                                        IsAccomplishLable = false,
                                                        IsAccomplishReview = false,
                                                        LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                                                        UltrasoundFileId = labeledUltrasoundFile.UltrasoundFileId
                                                    }
                                                },
                                                ReLabelCount = 0,
                                                ReLableReviewInfos = new List<ReLableReviewInfo>()
                                            }
                                        };

                                        await reLabelRecordDataManager.CreateReLabelRecordAsync(reLabelRecord);
                                    }

                                    #endregion
                                }
                            }

                            var progress = (int)((double)i / assignCount.Group * 100);
                            OperationManager.SetProgress(operationId, progress);
                        }

                        #endregion Create AssignedLabelCaseFile

                        //Create SameBatchLabelCase
                        var labelerInfo = new SameBatchLabelerInfo
                        {
                            Id = assignedLabeler.Id,
                            Name = assignedLabeler.Name,
                            AssignedLabelCaseId = assignedLabelCase.Id,
                            InstitutionId = institutionId,
                            AssignCount = assignCount,
                            AssignRestCount = assignCount,
                        };
                        sameBatchLabelCase.Labelers.Add(labelerInfo);
                        sameBatchLabelCase.ImageCaseId = imageCase.Id;
                        await sameBatchLabelCaseDataManager.CreateSameBatchLabelCaseAsync(sameBatchLabelCase);

                        #endregion Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile

                        #region Create LabelerGroup

                        var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                        var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(assignedLabeler.Id, institutionId, imageCategoryId);
                        if (labelerGroup == null)
                        {
                            labelerGroup = new LabelerGroup
                            {
                                Labeler = assignedLabeler,
                                ImageCategoryId = imageCategoryId,
                                OrganizationId = organization.Id,
                                LabelCaseQuantityItem = new AssignedCaseQuantityItem
                                {
                                    Total = assignCount.File,
                                    Remaining = assignCount.File,
                                },
                            };
                            await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                        }
                        else
                        {
                            labelerGroup.LabelCaseQuantityItem.Total += assignCount.File;
                            labelerGroup.LabelCaseQuantityItem.Remaining += assignCount.File;
                            await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                        }
                        #endregion
                    }

                    #region Update ImageBatch

                    var filesCount = labeledUltrasoundFiles.Count;
                    var findDetail = imageBatch.FileItem.QuestionedQuantityDetails.FirstOrDefault(x => x.Labeler.Id == questionedLabelerId);
                    if (findDetail != null)
                    {
                        findDetail.UnAssigned -= filesCount;
                        imageBatch.FileItem.QuestionedQuantity.UnAssigned -= filesCount;
                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageBatch);
                    }

                    #endregion

                    #region Update ImageCategory

                    findDetail = imageCategory.FileItem.QuestionedQuantityDetails.FirstOrDefault(x => x.Labeler.Id == questionedLabelerId);
                    if (findDetail != null)
                    {
                        findDetail.UnAssigned -= filesCount;
                        imageCategory.FileItem.QuestionedQuantity.UnAssigned -= filesCount;
                        await imageCategoryDataManager.UpdateImageCategoryAsync(imageCategory);
                    }

                    #endregion



                    OperationManager.SetProgress(operationId, 100);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} assigned questioned files to Labeler:{assignedLabeler.Name}, imageBatch Id:{imageBatchId}, CaseName:{caseName}, AssignCount:{filesCount}.");
                    return operationId;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }


        /// <summary>
        /// Assigned labeled files to reviewers for Developer Import. 
        /// </summary>
        /// <param name="sameBatchLabelCaseId"></param>
        /// <param name="isHideLabelerName"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public async Task<List<AssignedReviewCaseFile>> AssignReviewCaseForDeveloperAsync(long sameBatchLabelCaseId, List<EntityBase> reviewerList, bool isHideLabelerName)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
            var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
            var reviewCaseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
            var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
            var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();

            var operationId = IdCreator.CreateId();
            var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(sameBatchLabelCaseId);
            var labelCaseIds = sameBatchLabelCase.Labelers.Select(x => x.AssignedLabelCaseId);
            var reviewCaseImageNeed = new List<AssignedReviewCaseFile>();
            foreach (var reviewer in reviewerList)
            {
                #region Create assigned review case
                var imageCount = 0;

                //判断AssignedReviewCase 同一批次应该只存在一个AssignedReviewCase
                var assignedReviewCase = await reviewCaseDataManager.GetAssignedReviewedCaseByReviewerIdAndSameBatchLabelCaseIdAsync(reviewer.Id, sameBatchLabelCase.Id);
                if (assignedReviewCase == null)
                {
                    var casesCount = (int)await reviewCaseDataManager.GetAssignedReviewCaseCountAsync(reviewer.Id);
                    assignedReviewCase = new AssignedReviewCase
                    {
                        Name = sameBatchLabelCase.Name,
                        Reviewer = reviewer,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                        OrganizationId = sameBatchLabelCase.Organization.Id,
                        ImageCategoryId = sameBatchLabelCase.ImageCategoryId,
                        Count = sameBatchLabelCase.AssignCount,
                        CaseIndex = casesCount,
                    };
                    await reviewCaseDataManager.CreateAssignedReviewCaseAsync(assignedReviewCase);
                    await reviewCaseDataManager.AddAndReorderIndexToAssignedReviewCasesAsync(assignedReviewCase);
                }

                #endregion Create assigned review case

                var reviewCaseImages = new List<AssignedReviewCaseFile>();
                foreach (var labelCaseId in labelCaseIds)
                {
                    var assignedCase = await caseDataManager.GetAssignedLabelCaseAsync(labelCaseId);
                    //labeled case image.
                    var labelCaseImages = await caseDataManager.GetAssignedLabelCaseFilesByCaseIdAsync(assignedCase.Id);
                    foreach (var labelCaseImage in labelCaseImages)
                    {
                        #region Get assigned review case file
                        var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(labelCaseImage.LabeledUltrasoundFileIds.LastOrDefault().Key);
                        var labeledItem = new LabeledItem
                        {
                            Labeler = assignedCase.Labeler,
                            AssignedLabelCaseId = labelCaseId,
                            AssignedLabelCaseFileId = labelCaseImage.Id,
                            IsSkipped = labelCaseImage.IsSkipped,
                        };
                        labeledItem.LabeledUltrasoundFileInfos.Add(new LabeledFileInfo
                        {
                            CreateTime = labeledUltrasoundFile.CreateTime,
                            LabeledUltrasoundFileId = labeledUltrasoundFile.Id,
                            IsSkipped = labeledUltrasoundFile.IsSkipped,
                        });
                        var reviewCaseImage = reviewCaseImages.FirstOrDefault(x => x.AssignedReviewCaseId == assignedReviewCase.Id && x.Index == labelCaseImage.Index);
                        if (reviewCaseImage == null)
                        {
                            reviewCaseImage = new AssignedReviewCaseFile()
                            {
                                AssignedReviewCaseId = assignedReviewCase.Id,
                                ImageCategoryId = assignedReviewCase.ImageCategoryId,
                                Index = labelCaseImage.Index,
                                IsVideo = labelCaseImage.IsVideo,
                                FirstSubmissionTime = DateTime.Now
                            };
                            reviewCaseImage.LabeledItems.Add(labeledItem);
                            reviewCaseImages.Add(reviewCaseImage);
                        }
                        else
                        {   //Add de duplication judgment
                            var labeledItemsList = reviewCaseImage.LabeledItems;
                            if (!labeledItemsList.Any(x => x.Labeler.Id == assignedCase.Labeler.Id))
                            {
                                reviewCaseImage.LabeledItems.Add(labeledItem);
                            }
                        }

                        #endregion Get assigned review case file
                    }
                }

                #region Create assigned review case file
                foreach (var reviewCaseImage in reviewCaseImages)
                {
                    await reviewCaseDataManager.CreateAssignedReviewCaseFileAsync(reviewCaseImage);
                    //Update review state in labeled ultrasound image.
                    foreach (var labeledItem in reviewCaseImage.LabeledItems)
                    {
                        await labeledUltrasoundFileDataManager.UpdateLabeledUltrasoundFileReviewStateAsync(labeledItem.LabeledUltrasoundFileInfos.LastOrDefault().LabeledUltrasoundFileId, ReviewState.Assigned);
                    }
                    //新建则为当前获取的AssignedReviewCaseFiles 返回出去
                    reviewCaseImageNeed.Add(reviewCaseImage);
                    imageCount++;
                    var progress = (int)((double)imageCount / reviewCaseImages.Count() * 100);
                    OperationManager.SetProgress(operationId, progress);
                }
                #endregion

                assignedReviewCase.Count.File = reviewCaseImages.Count();
                await reviewCaseDataManager.UpdateAssignedReviewCaseAsync(assignedReviewCase);

                var reviewersList = sameBatchLabelCase.Reviewers.Select(x => x.Id).ToList();
                if (!reviewersList.Contains(reviewer.Id))
                {
                    sameBatchLabelCase.Reviewers.Add(new SameBatchReviewerInfo
                    {
                        Id = reviewer.Id,
                        Name = reviewer.Name,
                        State = ReviewState.Assigned,
                        AssignedReviewCaseId = assignedReviewCase.Id,
                    });
                }
            }
            sameBatchLabelCase.State = SameBatchLabelCaseState.ReviewerCompleted;
            sameBatchLabelCase.IsHideLabelerName = isHideLabelerName;
            await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
            OperationManager.SetProgress(operationId, 100);
            //await SystemLogger.WriteLogAsync($"Admin - {session.Name} assigned labeled files to reviewers:[{string.Join(',', reviewers)}], CaseName:{sameBatchLabelCase.Name}.");
            return reviewCaseImageNeed;

        }

        /// <summary>
        /// Get the progress of the assign operation.
        /// </summary>
        /// <param name="sessionId">The session id of the admin.</param>
        /// <param name="assignId">The id of the assign operation.</param>
        /// <returns>The progress of the assign operation.</returns>
        public async Task<int> GetAssignImagesProgressAsync(long sessionId, long assignId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    return await Task.FromResult(OperationManager.GetProgress(assignId));
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the un assigned image count.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The tag id.</param>
        /// <returns>The count of the un-assigned images.</returns>
        public async Task<int> GetUnAssignedImageCountAsync(long sessionId, long imageCategoryId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get un-assigned image count of {imageCategory.Name}.");
                    return (int)await ultrasoundFileDataManager.GetUnAssignedUltrasoundFileCountAsync(CategoryLevel.MainCategory, imageCategoryId);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get un-adoptable image count.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="imageCategoryId">The id of the tag.</param>
        /// <returns>The image's count.</returns>
        public async Task<int> GetUnAdoptableImageCountAsync(long sessionId, long imageCategoryId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(imageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get un-adoptable image count of {imageCategory.Name}.");
                    return (int)await ultrasoundFileDataManager.GetUnAdoptableUltrasoundFileCountAsync(CategoryLevel.MainCategory, imageCategoryId);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all assignedLabelCases count of one labeler.
        /// </summary>
        /// <param name="labelerId">The labelerId which the cases assigned to.</param>
        /// <returns>The assigned label case count.</returns>
        public async Task<int> GetAssignedLabelCaseCountAsync(long sessionId, long labelerId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    return (int)await caseDataManager.GetAssignedLabelCaseCountAsync(labelerId, keyword);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get cases which assigned to a labeler.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <returns>The cases of the labeler.</returns>
        public async Task<List<AssignedLabelCase>> GetAssignedLabelCasesByLabelerIdAsync(long sessionId, long labelerId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var assignedCases = await caseDataManager.GetAssignedLabelCasesByLabelerIdAsync(labelerId, pageIndex, pageSize, keyword);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of assigned label cases with keyword {keyword} by labelerId {labelerId}.");
                    return assignedCases;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the assigned label cases.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="sameBatchLabelCaseId">The id of the same batch label case</param>
        /// <returns>The cases</returns>
        public async Task<List<AssignedLabelCase>> GetAssignedLabelCasesBySameBatchLabelCaseIdAsync(long sessionId, long sameBatchLabelCaseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    return await caseDataManager.GetAssignedLabelCasesBySameBatchLabelCaseIdAsync(sameBatchLabelCaseId);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all the SameBatchLabelCase.
        /// </summary>
        /// <param name="pageIndex">The index of page.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// <param name="keyword">The searched keyword.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>The loaded SameBatchLabelCase.</returns>
        public async Task<List<SameBatchLabelCase>> GetSameBatchLabelCasesAsync(long sessionId, int pageIndex, int pageSize, long organizationId, long imageCategoryId, string keyword, DateTime start, DateTime end, DateTime updateStart, DateTime updateEnd)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var result = await sameBatchLabelCaseDataManager.GetSameBatchLabelCasesAsync(organizationId, imageCategoryId, keyword, pageIndex, pageSize, start, end, updateStart, updateEnd);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of SameBatchLabelCase with key {keyword} from system.");
                    return result;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all the SameBatchLabelCase.
        /// <param name="sessionId">The session id of the admin.</param>
        /// </summary>
        /// <returns>The loaded SameBatchLabelCase.</returns>
        public async Task<List<SameBatchLabelCase>> GetSameBatchLabelCasesAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                return await sameBatchLabelCaseDataManager.GetSameBatchLabelCasesAsync();
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the SameBatchLabelCases.
        /// </summary>
        /// <param name="id">The same batch label case id.</param>
        /// <returns>The loaded SameBatchLabelCase.</returns>
        public async Task<SameBatchLabelCase> GetSameBatchLabelCaseAsync(long sessionId, long id)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                return await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(id);
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get total case image count in case.
        /// </summary>
        /// <param name="sessionId">The session id.</param>
        /// <param name="caseId">The case id.</param>
        /// <returns>The count.</returns>
        public async Task<int> GetCaseImageCountAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get image count of case:{caseId}.");
                    return (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(caseId);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labeled case image count of one case.
        /// </summary>
        /// <param name="sessionId">The session id.</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>The count of the labeled case image</returns>
        public async Task<int> GetLabeledCaseImageCountAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled file count of case:{caseId}.");
                    return (int)await caseDataManager.GetLabeledAssignedLabelCaseFilesCountAsync(caseId);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get SameBatchLabelCase count.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="keyword">The searched keyword.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>The SameBatchLabelCase count</returns>
        public async Task<int> GetSameBatchLabelCaseCountAsync(long sessionId, long organizationId, long imageCategoryId, string keyword, DateTime start, DateTime end, DateTime updateStart, DateTime updateEnd)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get SameBatchLabelCaseCount:{keyword}.");
                    return (int)await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseCountAsync(organizationId, imageCategoryId, keyword, start, end, updateStart, updateEnd);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete the label case.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>Void</returns>
        public async Task DeleteLabelCaseAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundGroupDataManager = databaseService.GetManager<IUltrasoundGroupDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();
                    var goldStandardFileDataManager = databaseService.GetManager<IGoldStandardFileDataManager>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var labelCaseStatisticDataManager = databaseService.GetManager<ILabelCaseStatisticDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    var assignedLabelCase = await caseDataManager.GetAssignedLabelCaseAsync(caseId);
                    if (assignedLabelCase == null)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }
                    var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(assignedLabelCase.ImageCategoryId);
                    if (imageCategory == null)
                    {
                        throw new InvalidOperationException("ImageCategoryNotExist");
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(assignedLabelCase.ImageBatchId);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(assignedLabelCase.ImageCaseId);
                    if (imageCase == null)
                    {
                        throw new InvalidOperationException("ImageCaseNotExist");
                    }

                    #region Update SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    var assignedLabelCaseFiles = await caseDataManager.GetAssignedLabelCaseFilesByCaseIdAsync(assignedLabelCase.Id);
                    foreach (var assignedLabelCaseFile in assignedLabelCaseFiles)
                    {
                        long goldStandardLabeledFileId = 0;

                        #region Dalete LabeledUltrasoundFile & LabeledResult

                        foreach (var item in assignedLabelCaseFile.LabeledUltrasoundFileIds)
                        {
                            var labeledUltrasoundFile = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileExcludePreviewImageAsync(item.Key);
                            if (labeledUltrasoundFile != null)
                            {
                                foreach (var info in labeledUltrasoundFile.FileResultInfos)
                                {
                                    if (info.LabeledResultId > 0)
                                    {
                                        await labeledResultDataManager.DeleteLabeledResultAsync(info.LabeledResultId);
                                    }
                                }
                                await labeledUltrasoundFileDataManager.DeleteLabeledUltrasoundFileAsync(labeledUltrasoundFile.Id);

                                if (labeledUltrasoundFile.IsGoldStandard)
                                {
                                    goldStandardLabeledFileId = labeledUltrasoundFile.Id;
                                }
                            }
                        }
                        #endregion

                        #region Delete GoldStandard

                        if (goldStandardLabeledFileId > 0)
                        {
                            var goldStandardFile = await goldStandardFileDataManager.GetGoldStandardFileByUltrasoundFileIdAsync(assignedLabelCaseFile.UltrasoundFileId);
                            if (goldStandardFile != null)
                            {
                                await goldStandardFileDataManager.DeleteGoldStandardFileAsync(goldStandardFile.Id);
                                await SystemLogger.WriteLogAsync($"Admin - {session.Name} delete GoldStandardFile of UltrasoundFile {goldStandardFile.UltrasoundFileId}.");
                            }
                        }

                        #endregion

                        #region Delete AssignedLabelCaseFile

                        await caseDataManager.DeleteAssignedLabelCaseFileAsync(assignedLabelCaseFile.Id);

                        #endregion

                        #region Update ImageCategory QuantityItem UnAssigned

                        var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(assignedLabelCaseFile.UltrasoundFileId);
                        var findAssignedLabelCaseFile = await caseDataManager.GetAssignedLabelCaseFileByCaseIdAndUltrasoundFileIdAsync(assignedLabelCase.Id, ultrasoundFile.Id);
                        if (findAssignedLabelCaseFile == null)
                        {
                            imageCase.FileItem.Quantity.UnAssigned++;
                            findAssignedLabelCaseFile = await caseDataManager.GetLastAssignedLabelCaseFileByUltrasoundFileIdAsync(ultrasoundFile.Id);
                            if (findAssignedLabelCaseFile == null)
                            {
                                ultrasoundFile.Assigned = false;
                                imageBatch.FileItem.Quantity.UnAssigned++;
                                imageCategory.FileItem.Quantity.UnAssigned++;
                            }
                        }

                        #endregion

                        #region Update UltrasoundFile

                        var labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelAsync(CategoryLevel.Batch, assignedLabelCase.ImageBatchId, ultrasoundFile.Id);
                        if (labeledUltrasoundFiles == null || labeledUltrasoundFiles.Count == 0)
                        {
                            ultrasoundFile.Labeled = false;
                            ultrasoundFile.HasSeen = false;
                            ultrasoundFile.IsSkipped = false;
                            ultrasoundFile.IsAdoptable = false;
                            ultrasoundFile.GoldStandardLabeledFileId = -1;
                            ultrasoundFile.LabeledTypes = new LabelType[0];
                            ultrasoundFile.ImageCaseInfos.Clear();
                        }
                        else
                        {
                            ultrasoundFile.Labeled = labeledUltrasoundFiles.Any(x => !x.IsSkipped);
                            ultrasoundFile.HasSeen = true;
                            ultrasoundFile.IsSkipped = labeledUltrasoundFiles.All(x => x.IsSkipped);
                            ultrasoundFile.IsAdoptable = labeledUltrasoundFiles.Any(x => x.IsAdoptable);
                            labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelAsync(CategoryLevel.SameBatchLabelCase, assignedLabelCase.ImageCaseId, ultrasoundFile.Id);
                            for (int i = 0; i < ultrasoundFile.ImageCaseInfos.Count; i++)
                            {
                                var info = ultrasoundFile.ImageCaseInfos[i];
                                if (!labeledUltrasoundFiles.Any(x => x.ImageCaseId == info.Id))
                                {
                                    ultrasoundFile.ImageCaseInfos.Remove(info);
                                    i--;
                                }
                            }
                        }
                        await ultrasoundFileDataManager.UpdateUltrasoundFileAsync(ultrasoundFile);

                        #endregion
                    }

                    #region AssignedLabelCaseGroup

                    var assignedLabelCaseGroups = await caseDataManager.GetAssignedLabelCaseGroupsByCaseIdAsync(caseId);
                    foreach (var assignedLabelCaseGroup in assignedLabelCaseGroups)
                    {

                        #region Delete AssignedLabelCaseGroup

                        await caseDataManager.DeleteAssignedLabelCaseGroupAsync(assignedLabelCaseGroup.Id);

                        #endregion

                        #region Update ImageCategory QuantityItem UnAssigned

                        var ultrasoundGroup = await ultrasoundGroupDataManager.GetUltrasoundGroupAsync(assignedLabelCaseGroup.UltrasoundGroupId);
                        var findAssignedLabelCaseGroup = await caseDataManager.GetAssignedLabelCaseGroupByCaseIdAndUltrasoundGroupIdAsync(assignedLabelCase.Id, ultrasoundGroup.Id);
                        if (findAssignedLabelCaseGroup == null)
                        {
                            imageCase.GroupItem.Quantity.UnAssigned++;
                            findAssignedLabelCaseGroup = await caseDataManager.GetAssignedLabelCaseGroupByUltrasoundGroupIdAsync(ultrasoundGroup.Id);
                            if (findAssignedLabelCaseGroup == null)
                            {
                                ultrasoundGroup.Assigned = false;
                                imageBatch.GroupItem.Quantity.UnAssigned++;
                                imageCategory.GroupItem.Quantity.UnAssigned++;
                            }
                        }

                        #endregion

                        #region Update UltrasoundFile

                        var labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelByUltrasoundGroupIdAsync(CategoryLevel.Batch, assignedLabelCase.ImageBatchId, ultrasoundGroup.Id);
                        if (labeledUltrasoundFiles == null || labeledUltrasoundFiles.Count == 0)
                        {
                            ultrasoundGroup.Labeled = false;
                            ultrasoundGroup.HasSeen = false;
                            ultrasoundGroup.IsSkipped = false;
                            ultrasoundGroup.IsAdoptable = false;
                            ultrasoundGroup.HasGoldStandard = false;
                            ultrasoundGroup.LabeledTypes = new LabelType[0];
                            ultrasoundGroup.ImageCaseInfos.Clear();
                        }
                        else
                        {
                            ultrasoundGroup.Labeled = labeledUltrasoundFiles.Any(x => !x.IsSkipped);
                            ultrasoundGroup.HasSeen = true;
                            ultrasoundGroup.IsSkipped = labeledUltrasoundFiles.All(x => x.IsSkipped);
                            ultrasoundGroup.IsAdoptable = labeledUltrasoundFiles.Any(x => x.IsAdoptable);
                            labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesExcludePreviewAndIsRelabelByUltrasoundGroupIdAsync(CategoryLevel.SameBatchLabelCase, assignedLabelCase.ImageCaseId, ultrasoundGroup.Id);
                            for (int i = 0; i < ultrasoundGroup.ImageCaseInfos.Count; i++)
                            {
                                var info = ultrasoundGroup.ImageCaseInfos[i];
                                if (!labeledUltrasoundFiles.Any(x => x.ImageCaseId == info.Id))
                                {
                                    ultrasoundGroup.ImageCaseInfos.Remove(info);
                                    i--;
                                }
                            }
                        }
                        await ultrasoundGroupDataManager.UpdateUltrasoundGroupAsync(ultrasoundGroup);

                        #endregion
                    }

                    #endregion

                    #region Update LabelerGroup

                    var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(assignedLabelCase.Labeler.Id, assignedLabelCase.InstitutionId, imageCategory.Id);
                    if (labelerGroup != null)
                    {
                        labelerGroup.LabelCaseQuantityItem.Total -= assignedLabelCase.Count.File;
                        labelerGroup.LabelCaseQuantityItem.Submitted -= assignedLabelCase.SeenCount.File;
                        labelerGroup.LabelCaseQuantityItem.Valid -= assignedLabelCase.LabeledCount.File;
                        labelerGroup.LabelCaseQuantityItem.Remaining += assignedLabelCase.SeenCount.File;
                        if (labelerGroup.LabelCaseQuantityItem.Total == 0 && labelerGroup.ReviewCaseQuantityItem.Total == 0)
                        {
                            var count = await labelerGroupDataManager.GetLabelerGroupItemsCountAsync(labelerGroup.Id);
                            if (count == 0)
                            {
                                await labelerGroupDataManager.DeleteLabelerGroupAsync(labelerGroup.Id);
                            }
                        }
                        else
                        {
                            await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                        }
                    }
                    #endregion

                    #region Delete LabelerGroupItems

                    var labelerGroupItems = await labelerGroupDataManager.GetLabelerGroupItemsAsync(labelerGroup.Id, assignedLabelCase.Id, 0);
                    foreach (var item in labelerGroupItems)
                    {
                        item.LabelSubmittedCount = 0;
                        item.LabelValidCount = 0;
                        if (item.ReviewSubmittedCount == 0 && item.ReviewValidCount == 0)
                        {
                            await labelerGroupDataManager.DeleteLabelerGroupItemAsync(item.Id);
                        }
                        else
                        {
                            await labelerGroupDataManager.UpdateLabelerGroupItemAsync(item);
                        }
                    }

                    #endregion

                    #region Delete LabelCaseStatistic

                    if (assignedLabelCase.LabelCaseStatisticsId > 0)
                    {
                        await labelCaseStatisticDataManager.DeleteLabelCaseStatisticAsync(assignedLabelCase.LabelCaseStatisticsId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} delete LabelCaseStatistic Id {assignedLabelCase.LabelCaseStatisticsId}.");
                    }

                    #endregion

                    #region Update Labeler ScoreInfos

                    var labeler = await accountDataManager.GetAccountAsync(assignedLabelCase.Labeler.Id);
                    var scoreInfos = labeler.LabelerAuthorityInfo.ScoreInfos;
                    var findScoreInfo = scoreInfos.FirstOrDefault(x => x.ImageCategory.Id == imageCategory.Id);
                    if (findScoreInfo != null)
                    {
                        var findDetail = findScoreInfo.LabelCaseDetails.FirstOrDefault(x => x.AssignedLabelCaseId == assignedLabelCase.Id);
                        if (findDetail != null)
                        {
                            findDetail.GoldStandard.ConsistentCount = 0;
                            findDetail.GoldStandard.ConsistentRate = 0;
                            findDetail.SelfCheck.ConsistentCount = 0;
                            findDetail.SelfCheck.ConsistentRate = 0;
                        }
                        labeler.LabelerAuthorityInfo.LastAssignedLabelCaseGroupId = 0;
                        labeler.LabelerAuthorityInfo.LastAssignedLabelCaseFileId = 0;
                        await accountDataManager.UpdateAccountLabelerAuthorityInfoAsync(labeler.Id, labeler.LabelerAuthorityInfo);
                    }

                    #endregion Update Labeler ScoreInfos

                    #region Delete AssignedLabelCase

                    await caseDataManager.DeleteAssignedCaseAsync(assignedLabelCase.Id);
                    await caseDataManager.RemoveAndReorderIndexToAssignedLabelCasesAsync(assignedLabelCase);

                    #endregion

                    #region Update SameBatchLabelCase

                    var sameBatchLabelCase = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseAsync(assignedLabelCase.SameBatchLabelCaseId);
                    if (sameBatchLabelCase != null)
                    {
                        for (int i = 0; i < sameBatchLabelCase.Labelers.Count; i++)
                        {
                            var labelerInfo = sameBatchLabelCase.Labelers[i];
                            if (labelerInfo.AssignedLabelCaseId == assignedLabelCase.Id)
                            {
                                sameBatchLabelCase.Labelers.Remove(labelerInfo);
                                i--;
                            }
                        }
                        if (sameBatchLabelCase.Labelers.Count == 0)
                        {
                            await sameBatchLabelCaseDataManager.DeleteSameBatchLabelCaseAsync(sameBatchLabelCase.Id);
                            await imageCategoryDataManager.DeleteImageCategoryAsync(sameBatchLabelCase.ImageCaseId);
                            imageCase = null;
                        }
                        else if (sameBatchLabelCase.Labelers.All(x => x.State == ReviewState.Completed) && sameBatchLabelCase.State < SameBatchLabelCaseState.ReviewerAssigned)
                        {
                            sameBatchLabelCase.State = SameBatchLabelCaseState.LabelerCompleted;
                            await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
                        }
                        else
                        {
                            await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
                        }
                    }

                    #endregion

                    #endregion Update SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile & LabelerGroup

                    #region Update ImageCategory QuantityItem

                    await UpdateImageCategoryQuantityItemAsync(session, imageCategoryDataManager, ultrasoundFileDataManager, imageCategory, imageBatch, imageCase);

                    #endregion

                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted the assigned label case:{caseId}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Move up the label case.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>Void</returns>
        public async Task MoveUpLabelCaseAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var assignCase = await caseDataManager.GetAssignedLabelCaseAsync(caseId);
                    if (assignCase == null)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }

                    var oldCaseIndex = assignCase.CaseIndex;
                    var previousAssignCase = await caseDataManager.GetAssignedLabelCaseAsync(assignCase.Labeler.Id, oldCaseIndex - 1);
                    if (previousAssignCase != null)
                    {
                        previousAssignCase.CaseIndex = oldCaseIndex;
                        await caseDataManager.UpdateAssignCaseAsync(previousAssignCase);
                    }
                    assignCase.CaseIndex = oldCaseIndex - 1;
                    await caseDataManager.UpdateAssignCaseAsync(assignCase);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} move up the assigned label case:{caseId}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Move down the label case.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>Void</returns>
        public async Task MoveDownLabelCaseAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var assignCase = await caseDataManager.GetAssignedLabelCaseAsync(caseId);
                    if (assignCase == null)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }

                    var oldCaseIndex = assignCase.CaseIndex;
                    var laterAssignCase = await caseDataManager.GetAssignedLabelCaseAsync(assignCase.Labeler.Id, oldCaseIndex + 1);
                    if (laterAssignCase != null)
                    {
                        laterAssignCase.CaseIndex = oldCaseIndex;
                        await caseDataManager.UpdateAssignCaseAsync(laterAssignCase);
                    }
                    assignCase.CaseIndex = oldCaseIndex + 1;
                    await caseDataManager.UpdateAssignCaseAsync(assignCase);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} move down the assigned label case:{caseId}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the review cases which assigned to a reviewer.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="reviewerId">The id of the reviewer.</param>
        /// <returns>The cases of the labeler.</returns>
        public async Task<List<AssignedReviewCase>> GetAssignedReviewCasesByReviewerIdAsync(long sessionId, long reviewerId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    var assignedCases = await caseDataManager.GetAssignedReviewCasesByReviewerIdAsync(reviewerId, pageIndex, pageSize, keyword);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of assigned review cases with keyword {keyword} by reviewerId {reviewerId}.");
                    return assignedCases;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all assignedReviewCases count of one reviewer.
        /// </summary>
        /// <param name="reviewerId">The reviewerId which the cases assigned to.</param>
        /// <returns>The assigned review case count.</returns>
        public async Task<int> GetAssignedReviewCaseCountAsync(long sessionId, long reviewerId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    return (int)await caseDataManager.GetAssignedReviewCaseCountAsync(reviewerId, keyword);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete the review case.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>Void</returns>
        public async Task DeleteReviewCaseAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var assignedReviewCase = await caseDataManager.GetAssignedReviewCaseAsync(caseId);
                    if (assignedReviewCase == null)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }
                    await caseDataManager.DeleteAssignedReviewCaseAsync(caseId);
                    await caseDataManager.DeleteAssignedReviewCaseFilesAsync(caseId, assignedReviewCase.Reviewer.Id);
                    await caseDataManager.RemoveAndReorderIndexToAssignedReviewCasesAsync(assignedReviewCase);

                    var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(assignedReviewCase.Reviewer.Id, assignedReviewCase.InstitutionId, assignedReviewCase.ImageCategoryId);
                    if (labelerGroup != null)
                    {
                        #region Delete LabelerGroupItems

                        var labelerGroupItems = await labelerGroupDataManager.GetLabelerGroupItemsAsync(labelerGroup.Id, 0, assignedReviewCase.Id);
                        foreach (var item in labelerGroupItems)
                        {
                            item.ReviewSubmittedCount = 0;
                            item.ReviewValidCount = 0;
                            if (item.LabelSubmittedCount == 0 && item.LabelValidCount == 0)
                            {
                                await labelerGroupDataManager.DeleteLabelerGroupItemAsync(item.Id);
                            }
                            else
                            {
                                await labelerGroupDataManager.UpdateLabelerGroupItemAsync(item);
                            }
                        }
                        #endregion

                        #region Update LabelerGroup

                        labelerGroup.ReviewCaseQuantityItem.Total -= assignedReviewCase.Count.File;
                        labelerGroup.ReviewCaseQuantityItem.Submitted -= assignedReviewCase.SeenCount.File;
                        labelerGroup.ReviewCaseQuantityItem.Valid -= assignedReviewCase.ReviewedCount.File;
                        labelerGroup.ReviewCaseQuantityItem.Remaining += assignedReviewCase.SeenCount.File;
                        if (labelerGroup.LabelCaseQuantityItem.Total == 0 && labelerGroup.ReviewCaseQuantityItem.Total == 0)
                        {
                            var count = await labelerGroupDataManager.GetLabelerGroupItemsCountAsync(labelerGroup.Id);
                            if (count == 0)
                            {
                                await labelerGroupDataManager.DeleteLabelerGroupAsync(labelerGroup.Id);
                            }
                        }
                        else
                        {
                            await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                        }

                        #endregion

                    }
                    await caseDataManager.DeleteAssignedReviewCaseFilesAsync(caseId, assignedReviewCase.Reviewer.Id);
                    await caseDataManager.DeleteAssignedReviewCaseGroupsAsync(caseId);
                    await caseDataManager.DeleteAssignedReviewCaseAsync(caseId);
                    await caseDataManager.RemoveAndReorderIndexToAssignedReviewCasesAsync(assignedReviewCase);

                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted the assigned review case:{caseId}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Move up the review case.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>Void</returns>
        public async Task MoveUpReviewCaseAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    var assignCase = await caseDataManager.GetAssignedReviewCaseAsync(caseId);
                    if (assignCase == null)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }

                    var oldCaseIndex = assignCase.CaseIndex;
                    var previousAssignCase = await caseDataManager.GetAssignedReviewCaseByCaseIndexAsync(oldCaseIndex - 1, assignCase.Reviewer.Id);
                    if (previousAssignCase != null)
                    {
                        previousAssignCase.CaseIndex = oldCaseIndex;
                        await caseDataManager.UpdateAssignedReviewCaseAsync(previousAssignCase);
                    }
                    assignCase.CaseIndex = oldCaseIndex - 1;
                    await caseDataManager.UpdateAssignedReviewCaseAsync(assignCase);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} move up the assigned review case:{caseId}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Move down the review case.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseId">The id of the case.</param>
        /// <returns>Void</returns>
        public async Task MoveDownReviewCaseAsync(long sessionId, long caseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                    var assignCase = await caseDataManager.GetAssignedReviewCaseAsync(caseId);
                    if (assignCase == null)
                    {
                        throw new InvalidOperationException("AssignCaseNotExist");
                    }

                    var oldCaseIndex = assignCase.CaseIndex;
                    var laterAssignCase = await caseDataManager.GetAssignedReviewCaseByCaseIndexAsync(oldCaseIndex + 1, assignCase.Reviewer.Id);
                    if (laterAssignCase != null)
                    {
                        laterAssignCase.CaseIndex = oldCaseIndex;
                        await caseDataManager.UpdateAssignedReviewCaseAsync(laterAssignCase);
                    }
                    assignCase.CaseIndex = oldCaseIndex + 1;
                    await caseDataManager.UpdateAssignedReviewCaseAsync(assignCase);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} move down the assigned review case:{caseId}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Relabel and reassign label case to labeler.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="caseName">The same batch label case name.</param>
        /// <param name="labeler">The labeler.</param>
        /// <param name="isHideReviewerName">The value to indicate whether the labeler client hide reviewer name.</param>
        /// <param name="sourceAssignedLabelCaseId">The source assign label case id.</param>
        /// <returns></returns>
        public async Task<long> RelabelReassignedLabelCaseAsync(long sessionId, string caseName, EntityBase labeler, bool isHideReviewerName, long organizationId, long imageCategoryId, long imageCaseId, long sourceAssignedLabelCaseId, List<long> LabeledUltrasoundFileId, long reLabelRecordId, long reLabelRecourdCountId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var assignedLabeelCaseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var organizationDataManager = databaseService.GetManager<IOrganizationDataManager>();
                    var accountDataManager = databaseService.GetManager<IAccountDataManager>();

                    var sourceImageCase = await imageCategoryDataManager.GetImageCategoryAsync(imageCaseId);
                    if (sourceImageCase == null)
                    {
                        throw new InvalidOperationException("ImageCaseNotExist");
                    }
                    var imageBatch = await imageCategoryDataManager.GetImageCategoryAsync(sourceImageCase.Parent.Id);
                    if (imageBatch == null)
                    {
                        throw new InvalidOperationException("ImageBatchNotExist");
                    }
                    var imageCase = await imageCategoryDataManager.GetImageCategoryAsync(imageBatch.Id, caseName);
                    if (imageCase != null)
                    {
                        throw new InvalidOperationException("DuplicateName");
                    }

                    var sourceAssignedLabeelCaseFiles = await assignedLabeelCaseDataManager.GetReviewFailedAssignedLabelCaseFilesAsync(sourceAssignedLabelCaseId);

                    if (LabeledUltrasoundFileId != null)
                    {
                        sourceAssignedLabeelCaseFiles = new List<AssignedLabelCaseFile>();
                        foreach (var item in LabeledUltrasoundFileId)
                        {
                            var assignedLabelCaseFile = await assignedLabeelCaseDataManager.GetAssignedLabelCaseFileByLabeledUltrasoundFileIdAsync(item);
                            sourceAssignedLabeelCaseFiles.Add(assignedLabelCaseFile);
                            assignedLabelCaseFile.RelabelState = RelabelState.None;
                            assignedLabelCaseFile.QuestionedState = RelabelState.None;
                            await assignedLabeelCaseDataManager.UpdateAssignedLabelCaseFileAsync(assignedLabelCaseFile);
                        }
                    }
                    if (sourceAssignedLabeelCaseFiles.Count == 0)
                    {
                        throw new InvalidOperationException("NoRelabelImages");
                    }

                    var operationId = IdCreator.CreateId();
                    var ultrasoundFileIds = sourceAssignedLabeelCaseFiles.Select(x => x.UltrasoundFileId).Distinct().ToList();
                    var assignCount = new QuantityBase { File = ultrasoundFileIds.Count };

                    #region Create SameBatchLabelCase & ImageCase & AssignedLabelCase & AssignedLabelCaseFile

                    #region Create SameBatchLabelCase

                    var organization = await organizationDataManager.GetOrganizationAsync(organizationId);
                    var sameBatchLabelCase = new SameBatchLabelCase
                    {
                        Name = caseName,
                        Organization = new EntityBase { Id = organization.Id, Name = organization.Name },
                        ImageCategoryId = imageCategoryId,
                        ImageBatchId = imageBatch.Id,
                        Condition = AssignCondition.DeveloperQuestioned,
                        AssignCount = assignCount,
                        State = SameBatchLabelCaseState.LabelerAssigned,
                        IsHideReviewerName = isHideReviewerName,
                    };

                    #endregion Create SameBatchLabelCase

                    #region Create ImageCase

                    imageCase = new ImageCategory
                    {
                        Name = caseName,
                        Level = CategoryLevel.SameBatchLabelCase,
                        Parent = new EntityBase { Id = imageBatch.Id, Name = imageBatch.Name },
                        OrganizationId = organizationId,
                        LabelPackageContentId = imageBatch.LabelPackageContentId,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                    };
                    imageCase.Labelers.Add(labeler);
                    imageCase.GroupItem.Quantity.Total = assignCount.Group;
                    imageCase.GroupItem.Quantity.UnLabeled = assignCount.Group;
                    await imageCategoryDataManager.CreateImageCategoryAsync(imageCase);
                    if (!imageBatch.HasChildren)
                    {
                        await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(imageBatch.Id, true);
                    }

                    #endregion Create ImageCase

                    #region Create AssignedLabelCase

                    long institutionId = 0;
                    var account = await accountDataManager.GetAccountAsync(labeler.Id);
                    if (account != null)
                    {
                        institutionId = account.InstitutionId;
                    }
                    var caseIndex = 0;
                    var lastAssignedCase = await assignedLabeelCaseDataManager.GetLastIndexAssignedLabelCaseAsync(labeler.Id, imageCategoryId);
                    if (lastAssignedCase == null)
                    {
                        caseIndex = (int)await assignedLabeelCaseDataManager.GetAssignedLabelCaseCountAsync(labeler.Id);
                    }
                    else
                    {
                        caseIndex = lastAssignedCase.CaseIndex + 1;
                    }
                    var assignedLabelCase = new AssignedLabelCase
                    {
                        Name = caseName,
                        Labeler = labeler,
                        SameBatchLabelCaseId = sameBatchLabelCase.Id,
                        OrganizationId = organizationId,
                        ImageCategoryId = imageCategoryId,
                        ImageBatchId = imageBatch.Id,
                        ImageCaseId = imageCase.Id,
                        LabelPackageContentId = imageBatch.LabelPackageContentId,
                        InstitutionId = institutionId,
                        Count = assignCount,
                        CaseIndex = caseIndex,
                        RelabelState = RelabelState.LabelerAssigned,
                    };
                    await assignedLabeelCaseDataManager.CreateAssignedLabelCaseAsync(assignedLabelCase);
                    await assignedLabeelCaseDataManager.AddAndReorderIndexToAssignedLabelCasesAsync(assignedLabelCase);

                    #endregion Create AssignedLabelCase

                    #region Create AssignedLabelCaseFile

                    for (var i = 0; i < assignCount.Group; i++)
                    {
                        var ultrasoundFileId = ultrasoundFileIds[i];
                        var sourceAssignedLabeelCaseFile = sourceAssignedLabeelCaseFiles.FirstOrDefault(x => x.UltrasoundFileId == ultrasoundFileId);
                        var assignedLabelCaseFile = new AssignedLabelCaseFile
                        {
                            ImageCategoryId = assignedLabelCase.ImageCategoryId,
                            AssignedLabelCaseId = assignedLabelCase.Id,
                            UltrasoundFileId = ultrasoundFileId,
                            Index = i,
                            IsLabeled = false,
                            IsVideo = sourceAssignedLabeelCaseFile.IsVideo,
                            SourceLabeledUltrasoundFileId = sourceAssignedLabeelCaseFile.LabeledUltrasoundFileIds.LastOrDefault().Key,
                            RelabelState = RelabelState.LabelerAssigned,
                        };
                        await assignedLabeelCaseDataManager.CreateAssignedLabelCaseFileAsync(assignedLabelCaseFile);

                        var ultrasoundFile = await ultrasoundFileDataManager.GetUltrasoundFileExcludePreviewImageAsync(ultrasoundFileId);
                        if (!ultrasoundFile.ImageCaseInfos.Any(x => x.Id == imageCase.Id))
                        {
                            ultrasoundFile.ImageCaseInfos.Add(new ImageCaseInfo { Id = imageCase.Id });
                            await ultrasoundFileDataManager.UpdateImageCaseInfosForUltrasoundFileAsync(ultrasoundFile.Id, ultrasoundFile.ImageCaseInfos);
                        }

                        var progress = (int)((double)i / assignCount.File * 100);
                        OperationManager.SetProgress(operationId, progress);
                    }

                    #endregion Create AssignedLabelCaseFile

                    //Create SameBatchLabelCase
                    var labelerInfo = new SameBatchLabelerInfo
                    {
                        Id = labeler.Id,
                        Name = labeler.Name,
                        AssignedLabelCaseId = assignedLabelCase.Id,
                        InstitutionId = institutionId,
                        AssignCount = assignCount,
                        AssignRestCount = assignCount,
                    };
                    sameBatchLabelCase.Labelers.Add(labelerInfo);
                    sameBatchLabelCase.ImageCaseId = imageCase.Id;
                    await sameBatchLabelCaseDataManager.CreateSameBatchLabelCaseAsync(sameBatchLabelCase);

                    #endregion Create SameBatchLabelCase & AssignedLabelCase & AssignedLabelCaseFile

                    #region Create LabelerGroup

                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var labelerGroup = await labelerGroupDataManager.GetLabelerGroupAsync(labeler.Id, institutionId, imageCategoryId);
                    if (labelerGroup == null)
                    {
                        labelerGroup = new LabelerGroup
                        {
                            Labeler = labeler,
                            ImageCategoryId = imageCategoryId,
                            OrganizationId = organizationId,
                            LabelCaseQuantityItem = new AssignedCaseQuantityItem
                            {
                                Total = assignCount.File,
                                Remaining = assignCount.File,
                            },
                        };
                        await labelerGroupDataManager.CreateLabelerGroupAsync(labelerGroup);
                    }
                    else
                    {
                        labelerGroup.LabelCaseQuantityItem.Total += assignCount.File;
                        labelerGroup.LabelCaseQuantityItem.Remaining += assignCount.File;
                        await labelerGroupDataManager.UpdateLabelerGroupAsync(labelerGroup);
                    }
                    #endregion

                    #region Update ReLabelRecord 
                    if (reLabelRecordId != 0 && reLabelRecourdCountId != 0)
                    {
                        var reLabelRecordDataManager = databaseService.GetManager<IReLabelRecordDataManager>();
                        var relabelRecordData = await reLabelRecordDataManager.GetReLabelRecordAsync(reLabelRecordId);
                        if (relabelRecordData != null)
                        {
                            var relabelrecourdCountData = relabelRecordData.ReLabelRecordCounts.Where(x => x.Id == reLabelRecourdCountId).FirstOrDefault();
                            if (relabelrecourdCountData != null)
                            {
                                relabelrecourdCountData.NoPassCount -= assignCount.File;
                                relabelRecordData.IsAssign = true;
                                relabelRecordData.AssignInfo = new AssignInfo
                                {
                                    Labeler = labeler,
                                    SameBatchLabelCase = new EntityBase { Id = sameBatchLabelCase.Id, Name = sameBatchLabelCase.Name },
                                    AssignCount = assignCount.File,
                                };
                                await reLabelRecordDataManager.UpdateReLabelRecordAsync(relabelRecordData);
                            }
                            List<long> LabeledUltrasoundFileIdFinish = relabelrecourdCountData.NoPassLabeledUltrasoundFileIds.Where(x => x.IsAccomplishLable).Select(x => x.LabeledUltrasoundFileId).ToList();
                            var sameBatchLabelCaseOld = await sameBatchLabelCaseDataManager.GetSameBatchLabelCaseByAssignedLabelCaseIdAsync(relabelRecordData.SourceAssignedLabelCaseId);
                            if (sameBatchLabelCaseOld == null)
                            {
                                throw new InvalidOperationException("SameBatchLabelCaseNotExist");
                            }
                            var labelerService = ServiceManager.GetService<ILabelerService>() as LabelerService;
                            await labelerService.UpdateLabelerSorceAndLabelCaseStatistic(session, databaseService, sameBatchLabelCaseDataManager, relabelRecordData.SourceAssignedLabelCaseId, sameBatchLabelCaseOld, false, LabeledUltrasoundFileIdFinish, labeler.Id);

                            var findLabeler = sameBatchLabelCaseOld.Labelers.FirstOrDefault(x => x.Id == session.AccountId);
                            if (findLabeler != null)
                            {
                                findLabeler.State = ReviewState.Completed;
                            }
                            if (sameBatchLabelCaseOld.State < SameBatchLabelCaseState.ReviewerAssigned && sameBatchLabelCaseOld.Labelers.All(x => x.State == ReviewState.Completed))
                            {
                                sameBatchLabelCaseOld.State = SameBatchLabelCaseState.LabelerCompleted;
                            }
                            await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCaseOld);

                            await SystemLogger.WriteLogAsync($"Labeler - {session.Name} update assignedLabelCase {sameBatchLabelCaseOld.Name} is finished.");
                        }



                    }
                    #endregion

                    OperationManager.SetProgress(operationId, 100);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} relabel and reassign label case to Labeler:{labeler.Name}, imageBatch Id:{imageBatch.Id}, CaseName:{caseName}, AssignCount:{assignCount}.");
                    return operationId;
                }
            }

            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Create a label package content.
        /// </summary>
        /// <param name="sessionId">The session id of current admin.</param>
        /// <param name="content">content of the label package.</param>
        /// <returns>The id of the label package content.</returns>
        public async Task<long> CreateLabelPackageContentAsync(long sessionId, string content)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageContentDataManager = databaseService.GetManager<ILabelPackageContentDataManager>();
                    var labelPackageContent = new LabelPackageContent
                    {
                        Content = content,
                    };
                    await labelPackageContentDataManager.CreateLabelPackageContentAsync(labelPackageContent);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get label package content id.");
                    return labelPackageContent.Id;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the LabelPackageContent by id
        /// </summary>
        /// <param name="sessionId">The session id of current admin.</param>
        /// <param name="labelPackageContentId">The id of the label package content.</param>
        /// <returns>The loaded label package content</returns>
        public async Task<LabelPackageContent> GetLabelPackageContentAsync(long sessionId, long labelPackageContentId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageContentDataManager = databaseService.GetManager<ILabelPackageContentDataManager>();
                    var labelPackageContent = await labelPackageContentDataManager.GetLabelPackageContentAsync(labelPackageContentId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get label package content.");
                    return labelPackageContent;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update the label package content.
        /// </summary>
        /// <param name="sessionId">The session id of current admin.</param>
        /// <param name="labelPackageContentId">The id of the label package content.</param>
        /// <param name="content">The content of the label package content.</param>
        /// <returns>Void</returns>
        public async Task UpdateLabelPackageContentAsync(long sessionId, long labelPackageContentId, string content)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageContentDataManager = databaseService.GetManager<ILabelPackageContentDataManager>();
                    var labelPackageContent = await labelPackageContentDataManager.GetLabelPackageContentAsync(labelPackageContentId);
                    if (labelPackageContent != null)
                    {
                        labelPackageContent.Content = content;
                        await labelPackageContentDataManager.UpdateLabelPackageContentAsync(labelPackageContent);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} updated label package content.");
                    }
                    else
                    {
                        throw new InvalidOperationException("LabelPackageContentNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get all system label packages.
        /// </summary>
        /// <param name="sessionId">The session of current admin</param>
        /// <returns>The loaded admins</returns>
        public async Task<List<LabelPackage>> GetLabelPackagesAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageDataManager = databaseService.GetManager<ILabelPackageDataManager>();
                    var labelPackages = await labelPackageDataManager.GetLabelPackagesAsync();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get all label packages from system.");
                    return labelPackages;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Gets the label packages count by keyword.
        /// </summary>
        /// <returns>Label packages count from the system.</returns>
        public async Task<int> GetLabelPackagesCountAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageDataManager = databaseService.GetManager<ILabelPackageDataManager>();
                    var count = await labelPackageDataManager.GetLabelPackagesCountAsync(keyword, session.IsRoot, session.Organizations);
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Gets the label packages by keyword.
        /// </summary>
        /// <returns>Label packages from the system.</returns>
        public async Task<List<LabelPackage>> GetLabelPackagesAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageDataManager = databaseService.GetManager<ILabelPackageDataManager>();
                    var labelPackages = await labelPackageDataManager.GetLabelPackagesAsync(pageIndex, pageSize, keyword, session.IsRoot, session.Organizations);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of label packages with keyword {keyword} from system.");
                    return labelPackages;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Create a label package in system.
        /// </summary>
        /// <param name="sessionId">The session of current admin</param>
        /// <param name="name">The name of the LabelPackage</param>
        /// <param name="organizations">The organizations of the LabelPackage.</param>
        /// <returns>The created LabelPackage</returns>
        public async Task<LabelPackage> CreateLabelPackageAsync(long sessionId, string name, List<EntityBase> organizations)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageDataManager = databaseService.GetManager<ILabelPackageDataManager>();
                    var labelPackage = await labelPackageDataManager.GetLabelPackageAsync(name, organizations);
                    if (labelPackage == null)
                    {
                        #region Create the labelPackageContent

                        var labelPackageContentDataManager = databaseService.GetManager<ILabelPackageContentDataManager>();
                        var labelPackageContent = new LabelPackageContent();
                        await labelPackageContentDataManager.CreateLabelPackageContentAsync(labelPackageContent);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} created label package content id {labelPackageContent.Id}.");

                        #endregion Create the labelPackageContent

                        #region Create the labelPackage

                        labelPackage = new LabelPackage
                        {
                            Name = name,
                            ContentId = labelPackageContent.Id,
                            Organizations = organizations,
                        };
                        await labelPackageDataManager.CreateLabelPackageAsync(labelPackage);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} created the label package [{labelPackage.Name}]");

                        #endregion Create the labelPackage

                        #region Create the ImageCategory

                        var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                        foreach (var org in organizations)
                        {
                            var imageCategory = new ImageCategory
                            {
                                Level = CategoryLevel.MainCategory,
                                Name = labelPackage.Name,
                                LabelPackageContentId = labelPackageContent.Id,
                                OrganizationId = org.Id,
                                Parent = org,
                            };
                            await imageCategoryDataManager.CreateImageCategoryAsync(imageCategory);
                        }

                        #endregion Create the ImageCategory

                        return labelPackage;
                    }
                    throw new InvalidOperationException("LabelPackageAlreadyExists");
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete one label package from the system.
        /// </summary>
        /// <param name="sessionId">The session id of current admin.</param>
        /// <param name="labelPackageId">The id of the label package to process</param>
        /// <returns>Void</returns>
        public async Task DeleteLabelPackageAsync(long sessionId, long labelPackageId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelPackageDataManager = databaseService.GetManager<ILabelPackageDataManager>();
                    var labelPackage = await labelPackageDataManager.GetLabelPackageAsync(labelPackageId);
                    if (labelPackage != null)
                    {
                        var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                        await imageCategoryDataManager.DeleteImageCategoryByLabelPackageIdAsync(labelPackage.ContentId);
                        await labelPackageDataManager.DeleteLabelPackageAsync(labelPackageId);
                        var labelPackageContentDataManager = databaseService.GetManager<ILabelPackageContentDataManager>();
                        await labelPackageContentDataManager.DeleteLabelPackageContentAsync(labelPackage.ContentId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted the label package [{labelPackage.Name}]");
                    }
                    else
                    {
                        throw new InvalidOperationException("LabelPackageNotExist");
                    }
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get committed count.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>The committed count.</returns>
        public async Task<int> GetLabeledImageCountAsync(long sessionId, long labelerId, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled file count between {start} - {end}.");
                    return (int)await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileCountAsync(labelerId, start, end);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get committed count.
        /// </summary>
        /// <param name="sessionId">The session id of the admin</param>
        /// <param name="day">The start time.</param>
        /// <returns>The commit count of the day</returns>
        public async Task<int> GetDayCommittedCountAsync(long sessionId, DateTime day)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get committed image count of day {day}.");
                    var start = day.Date;
                    var end = day.Date.AddDays(1);
                    return (int)await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileCountAsync(start, end);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get committed region count.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>Get committed region count.</returns>
        public async Task<int> GetLabeledRegionCountAsync(long sessionId, long labelerId, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeled region count between {start} - {end}.");
                    return (int)await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFileRegionCountAsync(labelerId, start, end);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get assigned image count.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <returns>Get assigned image count.</returns>
        public async Task<int> GetAssignedImageCountAsync(long sessionId, long labelerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var assignedCases = await caseDataManager.GetAssignedLabelCasesByLabelerIdAsync(labelerId);
                    var imageCount = 0;
                    foreach (var assignedCase in assignedCases)
                    {
                        imageCount += (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(assignedCase.Id);
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get assigned image count of  labeler:{labelerId}.");
                    return imageCount;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get assigned image count.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <param name="start">The start time.</param>
        /// <param name="end">The end time.</param>
        /// <returns>Get assigned image count.</returns>
        public async Task<int> GetAssignedImageCountAsync(long sessionId, long labelerId, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var assignedCases = await caseDataManager.GetAssignedLabelCasesAsync(labelerId, start, end);
                    var imageCount = 0;
                    foreach (var assignedCase in assignedCases)
                    {
                        imageCount += (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(assignedCase.Id);
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get assigned image count of  labeler:{labelerId}.");
                    return imageCount;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get left image count.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="labelerId">The id of the labeler.</param>
        /// <returns>Get left image count.</returns>
        public async Task<int> GetUnlabeledAssignedImageCountAsync(long sessionId, long labelerId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var caseDataManager = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                    var assignedCases = await caseDataManager.GetAssignedLabelCasesByLabelerIdAsync(labelerId);
                    var imageCount = 0;
                    foreach (var assignedCase in assignedCases)
                    {
                        imageCount += (int)await caseDataManager.GetUnLabeledAssignedLabelCaseFilesCountAsync(assignedCase.Id);
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get unlabeled assigned image count of  labeler:{labelerId}.");
                    return imageCount;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get log item count.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <returns>The count of log item.</returns>
        public async Task<int> GetLogItemCountAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var logDataManager = databaseService.GetManager<ILogDataManager>();
                    return (int)await logDataManager.GetLogItemCountAsync();
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Gets log item for one page.
        /// </summary>
        /// <param name="sessionId">The admin session id.</param>
        /// <param name="pageIndex">The index of the page.</param>
        /// <param name="pageSize">Items per page.</param>
        /// <returns>loaded log items.</returns>
        public async Task<List<LogItem>> GetLogItemsAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var logDataManager = databaseService.GetManager<ILogDataManager>();
                    var result = await logDataManager.GetLogItemsAsync(pageIndex, pageSize, keyword);
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Add one labeler client.
        /// </summary>
        /// <param name="version">The version of labeler client.</param>
        /// <param name="description">The description of labeler client.</param>
        /// <param name="clientData">The data of the labeler client.</param>
        /// <param name="isDefault">True set to default.</param>
        /// <returns></returns>
        public async Task AddLabelerClientAsync(long sessionId, string fileName, string version, string description, byte[] clientData)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerClientDataManager = databaseService.GetManager<ILabelerClientDataManager>();
                    var clientInfo = await labelerClientDataManager.GetLabelerClientInfoAsync(version);
                    if (clientInfo != null)
                    {
                        throw new InvalidOperationException("SameVersionClientExist");
                    }
                    var defaultClientInfos = await labelerClientDataManager.GetDefaultLabelerClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await labelerClientDataManager.SetUndefaultLabelerClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo = new ClientUpgradeInfo
                    {
                        Name = Path.GetFileName(fileName),
                        Version = version,
                        Description = description,
                        IsDefault = true,
                    };
                    fileName = Path.Combine(CommonConfigManager.LabelerClientFolder, clientInfo.Id.ToString());
                    FileUtils.ByteToFile(fileName, clientInfo.Name, clientData);
                    await labelerClientDataManager.CreateLabelerClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} create labeler client info {version}.");
                    return;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all labeler client infos count.
        /// </summary>
        /// <returns>All labeler client infos count.</returns>
        public async Task<int> GetLabelerClientInfosCountAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerClientDataManager = databaseService.GetManager<ILabelerClientDataManager>();
                    var result = await labelerClientDataManager.GetLabelerClientInfosCountAsync();
                    return (int)result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the labeler client infos.
        /// </summary>
        /// <param name="pageIndex">The index of the page.</param>
        /// <param name="pageSize">Items per page.</param>
        /// <returns></returns>
        public async Task<List<ClientUpgradeInfo>> GetLabelerClientInfosAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerClientDataManager = databaseService.GetManager<ILabelerClientDataManager>();
                    var result = await labelerClientDataManager.GetLabelerClientInfosAsync(pageIndex, pageSize, keyword);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of labeler client infos.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete the labeler client info.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labelerClientInfoId">The labeler client info's id</param>
        /// <returns></returns>
        public async Task DeleteLabelerClientInfoAsync(long sessionId, long labelerClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerClientDataManager = databaseService.GetManager<ILabelerClientDataManager>();
                    var labelerClientInfo = await labelerClientDataManager.GetLabelerClientInfoAsync(labelerClientInfoId);
                    if (labelerClientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    await labelerClientDataManager.DeleteLabelerClientInfoAsync(labelerClientInfoId);
                    var labelerService = ServiceManager.GetService<ILabelerService>() as LabelerService;
                    labelerService?.RemoveClientData(labelerClientInfo.Version);

                    FileUtils.DeleteDirectory(Path.Combine(CommonConfigManager.LabelerClientFolder, labelerClientInfoId.ToString()));
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted labeler client info {labelerClientInfo.Version}.");

                    #region Set Default Client
                    if (labelerClientInfo.IsDefault)
                    {
                        var firstClientInfo = await labelerClientDataManager.GetLastLabelerClientInfoAsync();
                        if (firstClientInfo != null && !firstClientInfo.IsDefault)
                        {
                            firstClientInfo.IsDefault = true;
                            await labelerClientDataManager.UpdateLabelerClientInfoAsync(firstClientInfo);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} set labeler client info {firstClientInfo.Version} to default.");
                        }
                    }
                    #endregion
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Set the labeler client info to the default one.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labelerClientInfoId">The labeler clientInfo id</param>
        public async Task SetDefaultLabelerClientAsync(long sessionId, long labelerClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerClientDataManager = databaseService.GetManager<ILabelerClientDataManager>();
                    var clientInfo = await labelerClientDataManager.GetLabelerClientInfoAsync(labelerClientInfoId);
                    if (clientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    var defaultClientInfos = await labelerClientDataManager.GetDefaultLabelerClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await labelerClientDataManager.SetUndefaultLabelerClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo.IsDefault = true;
                    await labelerClientDataManager.UpdateLabelerClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} set labeler client info {clientInfo.Version} to default.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Assign conflict labeled data to Senior labelers.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns></returns>
        public async Task AssignConflictLabeledDataAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var sameBatchLabelCaseDataManager = databaseService.GetManager<ISameBatchLabelCaseDataManager>();
                    var labelerDataManager = databaseService.GetManager<ILabelerDataManager>();
                    var conflictCaseDataManager = databaseService.GetManager<IConflictCaseDataManager>();
                    var labeledUltrasoundFileDataManager = databaseService.GetManager<ILabeledUltrasoundFileDataManager>();
                    var ultrasoundFileDataManager = databaseService.GetManager<IUltrasoundFileDataManager>();
                    var seniorLabelers = await labelerDataManager.GetSeniorLabelersAsync(session.IsRoot, session.Organizations);
                    //seniorLabelers = seniorLabelers.Where(l => l.Score >= 3).ToList();
                    var seniorLabelersCount = seniorLabelers.Count;
                    if (seniorLabelers.Count == 0)
                    {
                        throw new InvalidOperationException("MissingSeniorLabeler");
                    }

                    var conflictSameBatchLabelCases = await sameBatchLabelCaseDataManager.GetUnAssignedConflictCasesAsync();
                    foreach (var sameBatchLabelCase in conflictSameBatchLabelCases)
                    {
                        var conflictUltrasoundFileIds = sameBatchLabelCase.InconsistentInfos.Select(x => x.UltrasoundFileId);
                        var conflictUltrasoundFilesCount = conflictUltrasoundFileIds.Count();
                        var eachImagesPerLabeler = conflictUltrasoundFilesCount / seniorLabelersCount;
                        var restConflictImagesCount = 0;
                        if (eachImagesPerLabeler < 1)
                        {
                            eachImagesPerLabeler = 1;
                        }
                        else
                        {
                            restConflictImagesCount = conflictUltrasoundFilesCount % seniorLabelersCount;
                        }

                        var labelerIndex = 0;
                        var lastConflictImageIndex = 0;
                        foreach (var labeler in seniorLabelers)
                        {
                            if (labelerIndex * eachImagesPerLabeler >= conflictUltrasoundFilesCount)
                            {
                                break;
                            }

                            var assignedImagesCount = eachImagesPerLabeler;
                            if (restConflictImagesCount > 0)
                            {
                                assignedImagesCount = eachImagesPerLabeler + 1;
                                restConflictImagesCount--;
                            }
                            var conflictCaseCount = (int)await conflictCaseDataManager.GetAssignedConflictCaseCountAsync(labeler.Id);
                            var conflictLabelCase = new AssignedConflictCase
                            {
                                CaseId = sameBatchLabelCase.Id,
                                CaseName = sameBatchLabelCase.Name,
                                CaseIndex = conflictCaseCount,
                                ReviewerId = labeler.Id,
                                Count = assignedImagesCount,
                            };
                            await conflictCaseDataManager.CreateAssignedConflictCaseAsync(conflictLabelCase);

                            for (var i = 0; i < assignedImagesCount; i++)
                            {
                                var ultrasoundFileIndex = lastConflictImageIndex + i;
                                if (ultrasoundFileIndex >= conflictUltrasoundFilesCount)
                                {
                                    break;
                                }

                                var ultrasoundFileId = sameBatchLabelCase.InconsistentInfos.FirstOrDefault(x => x.LabelCaseImageIndex == ultrasoundFileIndex).UltrasoundFileId;
                                var labeledUltrasoundFiles = await labeledUltrasoundFileDataManager.GetLabeledUltrasoundFilesByUltrasoundFileIdAndProjectionAsync(ultrasoundFileId);
                                var labeledUltrasoundFileIds = labeledUltrasoundFiles.Select(x => x.Id);
                                var assginedConflictImage = new AssignedConflictFile
                                {
                                    UltrasoundFileId = ultrasoundFileId,
                                    ImageIndex = i,
                                    AssignedConlictCaseId = conflictLabelCase.Id,
                                    LabeledUltrasoundFileIds = labeledUltrasoundFileIds
                                };
                                await conflictCaseDataManager.CreateAssignedConflictImageAsync(assginedConflictImage);
                            }

                            labelerIndex++;
                            lastConflictImageIndex = lastConflictImageIndex + assignedImagesCount;
                        }
                        sameBatchLabelCase.State = SameBatchLabelCaseState.ConflictHasAssigned;
                        await sameBatchLabelCaseDataManager.UpdateSameBatchLabelCaseAsync(sameBatchLabelCase);
                    }
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Add one reviewer client.
        /// </summary>
        /// <param name="version">The version of reviewer client.</param>
        /// <param name="description">The description of reviewer client.</param>
        /// <param name="clientData">The data of the reviewer client.</param>
        /// <returns></returns>
        public async Task AddReviewerClientAsync(long sessionId, string fileName, string version, string description, byte[] clientData)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reviewerClientDataManager = databaseService.GetManager<IReviewerClientDataManager>();
                    var clientInfo = await reviewerClientDataManager.GetReviewerClientInfoAsync(version);
                    if (clientInfo != null)
                    {
                        throw new InvalidOperationException("SameVersionClientExist");
                    }
                    var defaultClientInfos = await reviewerClientDataManager.GetDefaultReviewerClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await reviewerClientDataManager.SetUndefaultReviewerClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo = new ClientUpgradeInfo
                    {
                        Name = Path.GetFileName(fileName),
                        Version = version,
                        Description = description,
                        IsDefault = true,
                    };
                    fileName = Path.Combine(CommonConfigManager.ReviewerClientFolder, clientInfo.Id.ToString());
                    FileUtils.ByteToFile(fileName, clientInfo.Name, clientData);
                    await reviewerClientDataManager.CreateReviewerClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} create reviewer client info {version}.");
                    return;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Set the reviewer client info to the default one.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="reviewerClientInfoId">The reviewer clientInfo id</param>
        /// <returns></returns>
        public async Task SetDefaultReviewerClientAsync(long sessionId, long reviewerClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reviewerClientDataManager = databaseService.GetManager<IReviewerClientDataManager>();
                    var clientInfo = await reviewerClientDataManager.GetReviewerClientInfoAsync(reviewerClientInfoId);
                    if (clientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    var defaultClientInfos = await reviewerClientDataManager.GetDefaultReviewerClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await reviewerClientDataManager.SetUndefaultReviewerClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo.IsDefault = true;
                    await reviewerClientDataManager.UpdateReviewerClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} set reviewer client info {clientInfo.Version} to default.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the reviewer client infos.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns>The found reviewer client infos.</returns>
        public async Task<List<ClientUpgradeInfo>> GetReviewerClientInfosAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reviewerClientDataManager = databaseService.GetManager<IReviewerClientDataManager>();
                    var result = await reviewerClientDataManager.GetReviewerClientInfosAsync(pageIndex, pageSize, keyword);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of reviewer client infos from system.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all reviewer client infos.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns>All reviewer client infos.</returns>
        public async Task<int> GetReviewerClientInfosCountAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reviewerClientDataManager = databaseService.GetManager<IReviewerClientDataManager>();
                    var count = await reviewerClientDataManager.GetReviewerClientInfosCountAsync();
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete the reviewer client info.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labelerClientInfoId">The reviewer client info's id</param>
        /// <returns></returns>
        public async Task DeleteReviewerClientInfoAsync(long sessionId, long reviewerClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reviewerClientDataManager = databaseService.GetManager<IReviewerClientDataManager>();
                    var reviewerClientInfo = await reviewerClientDataManager.GetReviewerClientInfoAsync(reviewerClientInfoId);
                    if (reviewerClientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    await reviewerClientDataManager.DeleteReviewerClientInfoAsync(reviewerClientInfoId);
                    var reviewerService = ServiceManager.GetService<IReviewerService>() as ReviewerService;
                    reviewerService?.RemoveClientData(reviewerClientInfo.Version);

                    FileUtils.DeleteDirectory(Path.Combine(CommonConfigManager.ReviewerClientFolder, reviewerClientInfoId.ToString()));
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted reviewer client info {reviewerClientInfo.Version}.");

                    #region Set Default Client
                    if (reviewerClientInfo.IsDefault)
                    {
                        var firstClientInfo = await reviewerClientDataManager.GetLastReviewerClientInfoAsync();
                        if (firstClientInfo != null && !firstClientInfo.IsDefault)
                        {
                            firstClientInfo.IsDefault = true;
                            await reviewerClientDataManager.UpdateReviewerClientInfoAsync(firstClientInfo);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} set reviewer client info {firstClientInfo.Version} to default.");
                        }
                    }
                    #endregion
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the train tasks count by keyword.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The searched train tasks count.</returns>
        public async Task<int> GetTrainTasksCountAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var trainTaskDataManager = databaseService.GetManager<ITrainTaskDataManager>();
                    var count = await trainTaskDataManager.GetTrainTasksCountAsync(keyword, session.IsRoot, session.Organizations);
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Gets train tasks.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="keyword">The searched key word.</param>
        /// <returns>The searched train tasks.</returns>
        public async Task<List<TrainTaskModel>> GetTrainTasksAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var trainTaskDataManager = databaseService.GetManager<ITrainTaskDataManager>();
                    var trainTasks = await trainTaskDataManager.GetTrainTasksAsync(pageIndex, pageSize, keyword, session.IsRoot, session.Organizations);
                    var trainTaskModels = new List<TrainTaskModel>();
                    foreach (var trainTask in trainTasks)
                    {
                        var trainTaskMode = new TrainTaskModel
                        {
                            Id = trainTask.Id,
                            Name = trainTask.Name,
                            Developer = trainTask.Developer,
                            Organization = trainTask.Organization,
                            TrainFolder = trainTask.TrainFolder,
                            TestFolder = trainTask.TestFolder,
                            ScriptPackage = trainTask.ScriptPackage,
                        };
                        var trainStatus = await trainTaskDataManager.GetTrainTaskStatusResultAsync(trainTask.Id);
                        trainTaskMode.Result = trainStatus.Result;
                        trainTaskMode.StartTime = trainStatus.StartTime;
                        trainTaskMode.AgentIpAddress = trainStatus.AgentIpAddress;
                        trainTaskModels.Add(trainTaskMode);
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get train tasks by keyword {keyword}.");
                    return trainTaskModels;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Cancel train task.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="trainTaskId">The id of the train task.</param>
        /// <returns></returns>
        public async Task CancelTrainTaskAsync(long sessionId, long trainTaskId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var trainTaskDataManager = databaseService.GetManager<ITrainTaskDataManager>();
                    var trainTask = await trainTaskDataManager.GetTrainTaskAsync(trainTaskId);
                    if (trainTask == null)
                    {
                        throw new InvalidOperationException("TrainTaskNotExist");
                    }

                    await trainTaskDataManager.CancelTrainTaskStatusByTrainTaskId(trainTaskId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} cancel train task {trainTask.Name}.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Delete a train task from the system.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="trainTaskId">The id of the train task to be deleted.</param>
        /// <returns>Void</returns>
        public async Task DeleteTrainTaskAsync(long sessionId, long trainTaskId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var trainTaskDataManager = databaseService.GetManager<ITrainTaskDataManager>();
                    var trainTask = await trainTaskDataManager.GetTrainTaskAsync(trainTaskId);
                    if (trainTask == null)
                    {
                        throw new InvalidOperationException("TrainTaskNotExist");
                    }

                    await trainTaskDataManager.DeleteTrainTaskAsync(trainTaskId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted train task {trainTask.Name}");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the labeler client info by version.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="version">The version of the labeler client info..</param>
        /// <returns>All labeler client infos.</returns>
        public async Task<ClientUpgradeInfo> GetLabelerClientInfoByVersionAsync(long sessionId, string version)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerClientDataManager = databaseService.GetManager<ILabelerClientDataManager>();
                    var result = await labelerClientDataManager.GetLabelerClientInfoAsync(version);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get labeler client info by version {version}.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the reviewer client info by version.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="version">The version of the reviewer client info..</param>
        /// <returns>The reivewer client infos.</returns>
        public async Task<ClientUpgradeInfo> GetReviewerClientInfoByVersionAsync(long sessionId, string version)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reviewerClientDataManager = databaseService.GetManager<IReviewerClientDataManager>();
                    var result = await reviewerClientDataManager.GetReviewerClientInfoAsync(version);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get reviewer client info by version {version}.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labelers' label statistics.
        /// </summary>
        /// <param name="start">The start time</param>
        /// <param name="end">The end time</param>
        /// <returns>The labelers' label statistics.</returns>
        public async Task<List<LabelerLabelStatistic>> GetLabelerStatisticsAsync(long sessionId, int pageIndex, int pageSize, string keyword, long organizationId, long imageCategoryId, DateTime start, DateTime end)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    var labelerLabelStatistics = new List<LabelerLabelStatistic>();
                    var labelerGroups = await labelerGroupDataManager.GetLabelerGroupsAsync(keyword, pageIndex, pageSize, organizationId, imageCategoryId);
                    foreach (var labelerGroup in labelerGroups)
                    {
                        var labelerLabelStatistic = new LabelerLabelStatistic
                        {
                            Id = labelerGroup.Id,
                            Labeler = labelerGroup.Labeler,
                            OrganizationId = labelerGroup.OrganizationId,
                            ImageCategoryId = labelerGroup.ImageCategoryId,
                            LabelCaseQuantityItem = labelerGroup.LabelCaseQuantityItem,
                            ReviewCaseQuantityItem = labelerGroup.ReviewCaseQuantityItem,
                        };
                        var labelerGroupItems = await labelerGroupDataManager.GetLabelerGroupItemsAsync(labelerGroup.Id, start, end);
                        if (labelerGroupItems.Any())
                        {
                            foreach (var item in labelerGroupItems)
                            {
                                foreach (var subItem in item.AssignedLabelCaseFileItems)
                                {
                                    labelerLabelStatistic.ValidLabelCount += subItem.ValidCount + subItem.ValidOtherCount;
                                    labelerLabelStatistic.ModifyLabelCount += subItem.ModifyCount;
                                }
                                foreach (var subItem in item.AssignedReviewCaseFileItems)
                                {
                                    labelerLabelStatistic.ValidReviewCount += subItem.ValidCount + subItem.ValidOtherCount;
                                    labelerLabelStatistic.ModifyReviewCount = subItem.ModifyCount;
                                }
                            }
                            #region 兼容以前统计的数量

                            labelerLabelStatistic.ValidLabelCount += labelerGroupItems.Sum(x => x.LabelValidCount);
                            labelerLabelStatistic.ValidReviewCount += labelerGroupItems.Sum(x => x.ReviewValidCount);

                            #endregion
                        }
                        labelerLabelStatistics.Add(labelerLabelStatistic);
                    }
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of LabelerStatistics with key {keyword} from system.");
                    return labelerLabelStatistics;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get labelers' label groups count.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The labelers' label groups count</returns>
        public async Task<int> GetLabelerGroupsCountAsync(long sessionId, string keyword, long organizationId, long imageCategoryId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var labelerGroupDataManager = databaseService.GetManager<ILabelerGroupDataManager>();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get LabelerStatistics Count:{keyword}.");
                    var count = await labelerGroupDataManager.GetLabelerGroupsCountAsync(keyword, organizationId, imageCategoryId);
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        private class LabelImagesCountInfo
        {
            public int TotalAssignedCaseCount { get; set; }

            public int LabeledAssignedCaseCount { get; set; }

            public int TotalAssignedImageCount { get; set; }

            public int LabeledAssignedImageCount { get; set; }
        }

        private async Task<LabelImagesCountInfo> GetAssignedCasesAndImagesCount(IAssignedLabelCaseDataManager caseDataManager, long labelerId, DateTime startTime, DateTime endTime)
        {
            var assignedCases = await caseDataManager.GetAssignedLabelCasesAsync(labelerId, startTime, endTime);
            var totalAssignedCaseCount = assignedCases.Count;
            var labeledAssignedCaseCount = assignedCases.Count(c => c.LabelCaseStatisticsId != -1);
            var totalImageCount = 0;
            var labeledImageCount = 0;
            foreach (var assignedCase in assignedCases)
            {
                var totalCaseImageCount = (int)await caseDataManager.GetAssignedLabelCaseFilesCountAsync(assignedCase.Id);
                var labeledCaseImageCount = (int)await caseDataManager.GetLabeledAssignedLabelCaseFilesCountAsync(assignedCase.Id);
                totalImageCount += totalCaseImageCount;
                labeledImageCount += labeledCaseImageCount;
            }
            return new LabelImagesCountInfo
            {
                TotalAssignedCaseCount = totalAssignedCaseCount,
                LabeledAssignedCaseCount = labeledAssignedCaseCount,
                TotalAssignedImageCount = totalImageCount,
                LabeledAssignedImageCount = labeledImageCount
            };
        }

        private async Task<List<ImageLabelDataStatistic>> GetImageLabelDataStatisticList(List<LabeledUltrasoundFile> labeledUltrasoundFiles)
        {
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var labeledResultDataManager = databaseService.GetManager<ILabeledResultDataManager>();

            var labelDataStatistics = new List<ImageLabelDataStatistic>();
            for (var i = 0; i < labeledUltrasoundFiles.Count; i++)
            {
                var labeledUltrasoundFile = labeledUltrasoundFiles[i];
                var firstFileResultInfo = labeledUltrasoundFile.FileResultInfos.FirstOrDefault();
                var labelData = await labeledResultDataManager.GetLabeledResultAsync(firstFileResultInfo.LabeledResultId);
                if (labelData.ImageResults != null)
                {
                    foreach (var imageResult in labelData.ImageResults)
                    {
                        if (imageResult.Conclusion == null)
                        {
                            continue;
                        }

                        var existDataStatistic = labelDataStatistics.FirstOrDefault(s => s.Conclusion.Id == imageResult.Conclusion.Id);
                        if (existDataStatistic == null)
                        {
                            existDataStatistic = new ImageLabelDataStatistic
                            {
                                Conclusion = imageResult.Conclusion,
                                Unit = imageResult.Unit,
                            };
                            labelDataStatistics.Add(existDataStatistic);
                        }

                        existDataStatistic.Count++;
                    }
                }

                foreach (var roi in labelData.Rois)
                {
                    var existDataStatistic = labelDataStatistics.FirstOrDefault(s => s.Conclusion.Id == roi.Conclusion.Id);
                    if (existDataStatistic == null)
                    {
                        existDataStatistic = new ImageLabelDataStatistic
                        {
                            Conclusion = roi.Conclusion,
                            Unit = roi.Unit,
                        };

                        labelDataStatistics.Add(existDataStatistic);
                    }

                    existDataStatistic.Count++;
                }
            }
            return labelDataStatistics;
        }

        #region Developer client

        /// <summary>
        /// Add one developer client.
        /// </summary>
        /// <param name="version">The version of developer client.</param>
        /// <param name="description">The description of developer client.</param>
        /// <param name="clientData">The data of the developer client.</param>
        /// <returns></returns>
        public async Task AddDeveloperClientAsync(long sessionId, string fileName, string version, string description, byte[] clientData)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerClientDataManager = databaseService.GetManager<IDeveloperClientDataManager>();
                    var developerClientInfo = await developerClientDataManager.GetDeveloperClientInfoAsync(version);
                    if (developerClientInfo != null)
                    {
                        throw new InvalidOperationException("SameVersionClientExist");
                    }
                    var defaultClientInfos = await developerClientDataManager.GetDefaultDeveloperClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await developerClientDataManager.SetUndefaultDeveloperClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    developerClientInfo = new ClientUpgradeInfo
                    {
                        Name = Path.GetFileName(fileName),
                        Version = version,
                        Description = description,
                        IsDefault = true,
                    };
                    await developerClientDataManager.CreateDeveloperClientInfoAsync(developerClientInfo);
                    fileName = Path.Combine(CommonConfigManager.DeveloperClientFolder, developerClientInfo.Id.ToString());
                    FileUtils.ByteToFile(fileName, developerClientInfo.Name, clientData);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} create developer client info {version}.");
                    return;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Set the developer client info to the default one.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="developerClientInfoId">The developer clientInfo id</param>
        /// <returns></returns>
        public async Task SetDefaultDeveloperClientAsync(long sessionId, long developerClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerClientDataManager = databaseService.GetManager<IDeveloperClientDataManager>();
                    var clientInfo = await developerClientDataManager.GetDeveloperClientInfoAsync(developerClientInfoId);
                    if (clientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    var defaultClientInfos = await developerClientDataManager.GetDefaultDeveloperClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await developerClientDataManager.SetUndefaultDeveloperClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo.IsDefault = true;
                    await developerClientDataManager.UpdateDeveloperClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} set developer client info {clientInfo.Version} to default.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the developer client infos.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns>The found developer client infos.</returns>
        public async Task<List<ClientUpgradeInfo>> GetDeveloperClientInfosAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerClientDataManager = databaseService.GetManager<IDeveloperClientDataManager>();
                    var result = await developerClientDataManager.GetDeveloperClientInfosAsync(pageIndex, pageSize, keyword);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of developer client infos from system.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all developer client infos.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns>All developer client infos.</returns>
        public async Task<int> GetDeveloperClientInfosCountAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerClientDataManager = databaseService.GetManager<IDeveloperClientDataManager>();
                    var count = await developerClientDataManager.GetDeveloperClientInfosCountAsync();
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete the developer client info.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labelerClientInfoId">The developer client info's id</param>
        /// <returns></returns>
        public async Task DeleteDeveloperClientInfoAsync(long sessionId, long developerClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerClientDataManager = databaseService.GetManager<IDeveloperClientDataManager>();
                    var developerClientInfo = await developerClientDataManager.GetDeveloperClientInfoAsync(developerClientInfoId);
                    if (developerClientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    await developerClientDataManager.DeleteDeveloperClientInfoAsync(developerClientInfoId);
                    var developerService = ServiceManager.GetService<IDeveloperService>() as DeveloperService;
                    developerService?.RemoveClientData(developerClientInfo.Version);

                    FileUtils.DeleteDirectory(Path.Combine(CommonConfigManager.DeveloperClientFolder, developerClientInfoId.ToString()));
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted developer client info {developerClientInfo.Version}.");

                    #region Set Default DeveloperClient
                    if (developerClientInfo.IsDefault)
                    {
                        var firstClientInfo = await developerClientDataManager.GetLastDeveloperClientInfoAsync();
                        if (firstClientInfo != null && !firstClientInfo.IsDefault)
                        {
                            firstClientInfo.IsDefault = true;
                            await developerClientDataManager.UpdateDeveloperClientInfoAsync(firstClientInfo);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} set developer client info {firstClientInfo.Version} to default.");
                        }
                    }
                    #endregion
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the developer client info by version.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="version">The version of the developer client info..</param>
        /// <returns>The reivewer client infos.</returns>
        public async Task<ClientUpgradeInfo> GetDeveloperClientInfoByVersionAsync(long sessionId, string version)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var developerClientDataManager = databaseService.GetManager<IDeveloperClientDataManager>();
                    var result = await developerClientDataManager.GetDeveloperClientInfoAsync(version);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get developer client info by version {version}.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        #endregion Developer client

        #region Authority Menu

        /// <summary>
        ///  Get all system menus.
        /// </summary>
        /// <param name="sessionId"></param>
        /// <returns></returns>
        public async Task<List<AuthorityMenu>> GetAuthorityMenusAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var authorityMenuDataManager = databaseService.GetManager<IAuthorityMenuDataManager>();
                    var menus = await authorityMenuDataManager.GetAuthorityMenusAsync();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get all menus.");
                    return menus;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get defaulr authorities
        /// </summary>
        /// <returns></returns>
        public async Task<List<AuthorityMenu>> GetDefaultAuthorityMenusAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var authorityMenuDataManager = databaseService.GetManager<IAuthorityMenuDataManager>();
                    var menus = await authorityMenuDataManager.GetDefaultAuthorityMenusAsync();
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get default authorities.");
                    return menus;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        #endregion Authority Menu

        #region image category

        /// <summary>
        /// Create a image category.
        /// </summary>
        /// <returns></returns>
        public async Task<ImageCategory> CreateImageCategoryAsync(long sessionId, string name, CategoryLevel level, EntityBase parent, long organizatinId, long labelPackageContentId, long sameBatchLabelCaseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(parent.Id, name);
                if (imageCategory != null)
                {
                    throw new InvalidOperationException("DuplicateName");
                }
                imageCategory = new ImageCategory
                {
                    Name = name,
                    Level = level,
                    Parent = parent,
                    OrganizationId = organizatinId,
                    LabelPackageContentId = labelPackageContentId,
                    SameBatchLabelCaseId = sameBatchLabelCaseId,
                };
                await imageCategoryDataManager.CreateImageCategoryAsync(imageCategory);
                await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(parent.Id, true);
                await SystemLogger.WriteLogAsync($"Admin - {session.Name} create ImageCategory {name} in {parent.Name}.");
                return imageCategory;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete a image category.
        /// </summary>
        /// <returns>Void</returns>
        public async Task DeleteImageCategoryAsync(long sessionId, long id)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                await imageCategoryDataManager.DeleteImageCategoryAsync(id);
                await SystemLogger.WriteLogAsync($"Admin - {session.Name} delete ImageCategory id {id}.");
                return;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the image category by id.
        /// </summary>
        /// <param name="id">The searched id.</param>
        /// <returns>The loaded image category.</returns>
        public async Task<ImageCategory> GetImageCategoryAsync(long sessionId, long id)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                return await imageCategoryDataManager.GetImageCategoryAsync(id);
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the image categories count by keyword.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The found image categories count.</returns>
        public async Task<int> GetImageCategoriesCountAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var organizationIds = session.Organizations.Select(x => x.Id).ToList();
                var count = await imageCategoryDataManager.GetImageCategoriesCountAsync(keyword, session.IsRoot, organizationIds);
                return (int)count;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the image categories by keyword.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The loaded image categories.</returns>
        public async Task<List<ImageCategory>> GetImageCategoriesAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var organizationIds = session.Organizations.Select(x => x.Id).ToList();
                return await imageCategoryDataManager.GetImageCategoriesAsync(keyword, pageIndex, pageSize, session.IsRoot, organizationIds);
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the image categories by key word.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The loaded image categories.</returns>
        public async Task<List<ImageCategory>> GetImageCategoriesAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategories = await imageCategoryDataManager.GetImageCategoriesByKeywordAsync(keyword);
                return imageCategories;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the image categories by parent id.
        /// </summary>
        /// <param name="parentId">The searched parent id.</param>
        /// <returns>The loaded image categories.</returns>
        public async Task<List<ImageCategory>> GetImageCategoriesByParentIdAsync(long sessionId, long parentId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategories = await imageCategoryDataManager.GetImageCategoriesByParentIdAsync(parentId);
                return imageCategories;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the image categories by category level.
        /// </summary>
        /// <param name="level">The searched category level.</param>
        /// <returns>The loaded image categories.</returns>
        public async Task<List<ImageCategory>> GetImageCategoriesByLevelAsync(long sessionId, CategoryLevel level)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategories = await imageCategoryDataManager.GetImageCategoriesByLevelAsync(level);
                return imageCategories;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the cases of image categories by parent id.
        /// </summary>
        /// <param name="parentId">The searched parent id.</param>
        /// <returns>The loaded image categories.</returns>
        public async Task<List<ImageCategory>> GetImageCategoriesWithRelabeledCaseByParentIdAsync(long sessionId, long parentId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();

                var items = new List<ImageCategory>();
                var imageCategories = await imageCategoryDataManager.GetImageCategoriesByParentIdAsync(parentId);
                if (imageCategories != null && imageCategories.Count > 0)
                {
                    foreach (var item in imageCategories)
                    {
                        items.Add(item);
                        await AddImageCategoriesChildAsync(imageCategoryDataManager, item.Id, items);
                    }
                }
                return items;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        private async Task AddImageCategoriesChildAsync(IImageCategoryDataManager imageCategoryDataManager, long parentId, List<ImageCategory> items)
        {
            var imageCategories = await imageCategoryDataManager.GetImageCategoriesByParentIdAsync(parentId);
            if (imageCategories != null && imageCategories.Count > 0)
            {
                foreach (var item in imageCategories)
                {
                    items.Add(item);
                    await AddImageCategoriesChildAsync(imageCategoryDataManager, item.Id, items);
                }
            }
        }

        /// <summary>
        /// Get the image categories by labelPackageId.
        /// </summary>
        /// <param name="labelPackageContentId">The label package content id.</param>
        /// <returns>The loaded ImageCategories</returns>
        public async Task<List<ImageCategory>> GetImageCategoriesHasChildrenAsync(long sessionId, long labelPackageContentId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategories = await imageCategoryDataManager.GetImageCategoriesHasChildrenAsync(labelPackageContentId);
                return imageCategories;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update the image category hasChildren in system.
        /// </summary>
        /// <returns></returns>
        public async Task UpdateImageCategoryHasChildrenAsync(long sessionId, long id, bool hasChildren)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                await imageCategoryDataManager.UpdateImageCategoryHasChildrenAsync(id, hasChildren);
                return;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update the image category that assigned users in system.
        /// </summary>
        /// <returns></returns>
        public async Task UpdateImageCategoryUsersAsync(long sessionId, long id, AccountType accountType, List<EntityBase> users)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                switch (accountType)
                {
                    case AccountType.Developer:
                        await imageCategoryDataManager.UpdateImageCategoryDevelopersAsync(id, users);
                        break;

                    case AccountType.Labeler:
                        await imageCategoryDataManager.UpdateImageCategoryLabelersAsync(id, users);
                        break;

                    case AccountType.Sharer:
                        await imageCategoryDataManager.UpdateImageCategorySharersAsync(id, users);
                        break;

                    default:
                        break;
                }
                return;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update the image category gold standard and self-check image quantity item in system.
        /// </summary>
        /// <returns></returns>
        public async Task UpdateImageCategoryGoldStandardAndSelfCheckQuantityItemAsync(long sessionId, long id, double goldStandardProportion, int goldStandardQualifiedPeople, double selfCheckProportion, bool isSupportedSkipFrame, VideoItem videoItem, DifficultyLevel difficultyLevel)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var imageCategoryDataManager = databaseService.GetManager<IImageCategoryDataManager>();
                var imageCategory = await imageCategoryDataManager.GetImageCategoryAsync(id);
                if (imageCategory == null)
                {
                    throw new InvalidOperationException("ImageCategoryNotExist");
                }
                imageCategory.FileItem.GoldStandardQuantity ??= new GoldStandardQuantityItem();
                imageCategory.FileItem.GoldStandardQuantity.Proportion = goldStandardProportion;
                imageCategory.FileItem.GoldStandardQuantity.QualifiedPeople = goldStandardQualifiedPeople;
                var total = Math.Round(imageCategory.FileItem.Quantity.Total * goldStandardProportion);
                imageCategory.FileItem.GoldStandardQuantity.ToBeAdded = (int)total - imageCategory.FileItem.GoldStandardQuantity.Existing;
                imageCategory.FileItem.SelfCheckQuantity ??= new SelfCheckQuantityItem();
                imageCategory.FileItem.SelfCheckQuantity.Proportion = selfCheckProportion;
                imageCategory.IsSupportedSkipFrame = isSupportedSkipFrame;
                imageCategory.VideoItem = videoItem;
                imageCategory.DifficultyLevel = difficultyLevel;
                await imageCategoryDataManager.UpdateImageCategoryAsync(imageCategory);
                return;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        #endregion image category

        #region Developer share info

        /// <summary>
        /// Gets the developer share infos by keyword.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The loaded developer share infos.</returns>
        public async Task<List<DeveloperShareInfo>> GetDeveloperShareInfosAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var developerShareInfoDataManager = databaseService.GetManager<IDeveloperShareInfoDataManager>();
                var ids = session.Organizations.Select(x => x.Id).ToList();
                return await developerShareInfoDataManager.GetDeveloperShareInfosAsync(pageIndex, pageSize, keyword, session.IsRoot, ids);
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Gets the developer share infos count by keyword.
        /// </summary>
        /// <param name="keyword">The searched keyword.</param>
        /// <returns>The loaded ldeveloper share infos count.</returns>
        public async Task<int> GetDeveloperShareInfosCountAsync(long sessionId, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var developerShareInfoDataManager = databaseService.GetManager<IDeveloperShareInfoDataManager>();
                var ids = session.Organizations.Select(x => x.Id).ToList();
                var count = await developerShareInfoDataManager.GetDeveloperShareInfosCountAsync(keyword, session.IsRoot, ids);
                return (int)count;
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Update shared developer folder
        /// </summary>
        /// <param name="state">The approval state</param>
        /// <returns></returns>
        public async Task UpdateSharedDeveloperFolderAsync(long sessionId, long id, ApprovalState state)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null && session.Type == SessionType.Admin)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var developerShareInfoDataManager = databaseService.GetManager<IDeveloperShareInfoDataManager>();
                var imageFolderDataManager = databaseService.GetManager<IDeveloperFolderDataManager>();

                #region Update DeveloperShareInfo

                var shareInfo = await developerShareInfoDataManager.GetDeveloperShareInfoAsync(id);
                if (shareInfo == null)
                {
                    throw new InvalidOperationException("DeveloperShareInfoNotExist");
                }
                var approver = new EntityBase { Id = session.AccountId, Name = session.Name };
                shareInfo.ApprovalState = state;
                shareInfo.Approver = approver;
                await developerShareInfoDataManager.UpdateDeveloperShareInfoAsync(shareInfo);

                #endregion Update DeveloperShareInfo

                #region Update DeveloperFolder

                var folderId = shareInfo.DeveloperFolderId;
                var developerFolder = await imageFolderDataManager.GetDeveloperFolderAsync(folderId);
                if (developerFolder == null)
                {
                    throw new InvalidOperationException("DeveloperFolderNotExist");
                }
                await imageFolderDataManager.UpdateSharedDeveloperFolderAsync(folderId, state, developerFolder.Sharers, approver);
                await SystemLogger.WriteLogAsync($"Admin - {session.Name} update shared developer folder {developerFolder.Name} to {state}.");

                #endregion Update DeveloperFolder
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        #endregion Developer share info

        /// <summary>
        /// Get the reviewer client info by ultrasoundId.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="ultrasoundId">ultrasoundId</param>
        /// <returns>The TreatingProcess.</returns>
        public async Task<TreatingProcess> GetTreatingProcessByultrasoundId(long sessionId, long ultrasoundId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    try
                    {
                        var databaseService = ServiceManager.GetService<IDatabaseService>();
                        var treatingProcessManger = databaseService.GetManager<ITreatingProcessDataManager>();
                        var result = await treatingProcessManger.GetTreatingProcessByUltrasoundFilesIdAsync(ultrasoundId);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} get TreatingProcess by ultrasoundId {ultrasoundId}.");
                        return result;
                    }
                    catch (Exception ex)
                    {
                        return new TreatingProcess();
                    }
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }
        /// <summary>
        /// Get the reviewer client info by SameBatchLabelCaseId.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="ultrasoundId">SameBatchLabelCaseId</param>
        /// <returns>The ReLabelRecord.</returns>
        public async Task<List<ReLabelRecord>> GetReLabelRecordBySameBatchLabelCaseId(long sessionId, long SameBatchLabelCaseId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var reLabelRecordManger = databaseService.GetManager<IReLabelRecordDataManager>();
                    var result = await reLabelRecordManger.GetReLabelRecordBySameBatchLabelCaseIdAsync(SameBatchLabelCaseId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get TreatingProcess by ultrasoundId {SameBatchLabelCaseId}.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }
        /// <summary>
        /// 将未重审数据分配新的审核人员
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="assignedLabelCaseId"></param>
        /// <param name="laberUltrasoundFileIds"></param>
        /// <param name="reviewer"></param>
        /// <param name="ImageCategoryId"></param>
        /// <param name="reLabelRecordCountId"></param>
        /// <param name="reLabelRecordId"></param>
        /// <returns></returns>
        public async Task ReAssignReviewCaseAsync(long sessionId, long assignedLabelCaseId, List<long> laberUltrasoundFileIds, EntityBase reviewer, long ImageCategoryId, long reLabelRecordCountId, long reLabelRecordId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var reviewCaseDataManager = databaseService.GetManager<IAssignedReviewCaseDataManager>();
                var reLabelRecordData = databaseService.GetManager<IReLabelRecordDataManager>();

                var sourAssignedReviewCaseData = await reviewCaseDataManager.GetAssignedReviewCaseFileByAssignedLabelCaseIdAsync(assignedLabelCaseId);
                if (sourAssignedReviewCaseData == null)
                {
                    return;
                }
                var sourReveiwCaseData = await reviewCaseDataManager.GetAssignedReviewCaseAsync(sourAssignedReviewCaseData.AssignedReviewCaseId);

                if (sourReveiwCaseData == null || sourReveiwCaseData.Reviewer.Id == reviewer.Id)
                {
                    return;
                }
                var lastAssignedReviewCase = await reviewCaseDataManager.GetLastIndexAssignedReviewCaseAsync(reviewer.Id, ImageCategoryId);
                var caseIndex = 0;
                var reviewCaseNewId = IdCreator.CreateId();
                if (lastAssignedReviewCase == null)
                {
                    caseIndex = (int)await reviewCaseDataManager.GetAssignedReviewCaseCountAsync(reviewer.Id);
                }
                else
                {
                    caseIndex = lastAssignedReviewCase.CaseIndex + 1;
                }
                var reviewCaseFilesData = await reviewCaseDataManager.GetAssignedReviewCaseFilesAsync(sourReveiwCaseData.Id);
                var count = new QuantityBase();
                if (reviewCaseFilesData != null)
                {
                    var reviewCaseFilesFilterData = reviewCaseFilesData.Where(x => x.LabeledItems.Any(y => y.LabeledUltrasoundFileInfos.Any(q => laberUltrasoundFileIds.Contains(q.LabeledUltrasoundFileId)))).ToList();
                    count.File = reviewCaseFilesFilterData.Count;
                    var i = 0;
                    foreach (var item in reviewCaseFilesFilterData)
                    {
                        await reviewCaseDataManager.UpdateAssignedReviewCaseFilesQuestionedStateAndRelaState(item.Id);
                        item.Id = IdCreator.CreateId();
                        item.AssignedReviewCaseId = reviewCaseNewId;
                        item.Index = i;
                        await reviewCaseDataManager.CreateAssignedReviewCaseFileAsync(item);
                        i++;
                    }
                }
                await reviewCaseDataManager.UpdateAssignedReviewCaseRelabelStateAsync(sourReveiwCaseData.Id, RelabelState.None);
                sourReveiwCaseData.Id = reviewCaseNewId;
                sourReveiwCaseData.CaseIndex = caseIndex;
                sourReveiwCaseData.Reviewer = reviewer;
                sourReveiwCaseData.CreateTime = DateTime.UtcNow;
                sourReveiwCaseData.Count = count;
                sourReveiwCaseData.ReviewedCount = count;
                sourReveiwCaseData.SeenCount = count;
                await reviewCaseDataManager.CreateAssignedReviewCaseAsync(sourReveiwCaseData);
                await reviewCaseDataManager.AddAndReorderIndexToAssignedReviewCasesAsync(sourReveiwCaseData);

                var relabelrecord = await reLabelRecordData.GetReLabelRecordAsync(reLabelRecordId);
                if (relabelrecord != null)
                {
                    var reLabelRecordCount = relabelrecord.ReLabelRecordCounts.Where(x => x.Id == reLabelRecordCountId).FirstOrDefault();
                    if (reLabelRecordCount != null)
                    {
                        var relabelreviewCurr = reLabelRecordCount.ReLableReviewInfos.Where(x => x.IsCurrent).FirstOrDefault();
                        if (relabelreviewCurr != null)
                        {
                            relabelreviewCurr.Count = relabelreviewCurr.ReviewCount;
                            relabelreviewCurr.IsCurrent = false;
                        }

                        reLabelRecordCount.ReLableReviewInfos.Add(new ReLableReviewInfo
                        {
                            Count = count.File,
                            ReviewCount = 0,
                            Reviewer = reviewer,
                            IsCurrent = true
                        });
                        await reLabelRecordData.UpdateReLabelRecordAsync(relabelrecord);
                    }
                }
            }
        }
        /// <summary>
        /// 获取质疑数据，通过batch id
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="batchId"></param>
        /// <returns></returns>
        public async Task<List<AssignQuestionCaseViewModel>> GetQusetionInfoByBatchId(long sessionId, long batchId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            var assignQuestionsResult = new List<AssignQuestionCaseViewModel>();
            if (session != null)
            {
                var databaseService = ServiceManager.GetService<IDatabaseService>();
                var assignedLabelCaseDataManger = databaseService.GetManager<IAssignedLabelCaseDataManager>();
                var developerLabeledUltrasoundFileDataManager = databaseService.GetManager<IDeveloperLabeledUltrasoundFileDataManager>();
                var assignedLabelCaseDatas = await assignedLabelCaseDataManger.GetAssignedLabelCaseByImageBatchId(batchId);
                if (assignedLabelCaseDatas != null)
                {
                    foreach (var item in assignedLabelCaseDatas)
                    {
                        var assignQuestionCase = new AssignQuestionCaseViewModel();
                        assignQuestionCase.Id = item.Id;
                        assignQuestionCase.OriginalCase_Name = item.Name;
                        assignQuestionCase.Question_User = item.Labeler.Name;
                        assignQuestionCase.Question_Id = item.Labeler.Id;
                        assignQuestionCase.NewCase_Name = "质疑_";
                        if (assignQuestionCase.assignedLabelCaseIds == null)
                        {
                            assignQuestionCase.assignedLabelCaseIds = new List<long>();
                        }
                        assignQuestionCase.assignedLabelCaseIds.Add(item.Id);
                        var questionCount = await developerLabeledUltrasoundFileDataManager.GetQuestionForPendingAssignedCount(item.Id);
                        assignQuestionCase.Question_Count = (int)questionCount;
                        if (questionCount > 0)
                        {
                            assignQuestionsResult.Add(assignQuestionCase);
                        }
                    }
                }
            }
            return assignQuestionsResult;
        }

        #region 呼吸机数据管理

        /// <summary>
        /// 添加原始数据并解析.
        /// </summary>
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <returns>Void</returns>
        public async Task<VentilatorOpResult> AddUnLabeledVentilatorFileAsync(long sessionId, long organizationId, VentilatorFile ventilatorFile, byte[] byteData, string fileName)
        {
            var result = new VentilatorOpResult() { ResultCode = OpResultCode.Success };
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    string tempFolderPath;
                    if (ventilatorFile == null)
                    {
                        ventilatorFile = new VentilatorFile
                        {
                            State = LabelState.Unlabeled,
                            OrganizationId = organizationId,
                        };
                        tempFolderPath = Path.Combine(CommonConfigManager.VentilatorTransformTempFolder, ventilatorFile.Id.ToString());
                        FileUtils.DeleteDirectory(tempFolderPath);
                    }
                    else
                    {
                        tempFolderPath = Path.Combine(CommonConfigManager.VentilatorTransformTempFolder, ventilatorFile.Id.ToString());
                    }
                    ImageDataFormat imageDataFormat = ImageDataFormat.RawData;
                    var extension = Path.GetExtension(fileName);
                    switch (extension.ToLower())
                    {
                        case ".evt":
                            imageDataFormat = ImageDataFormat.Evt;
                            break;
                        case ".dat":
                            imageDataFormat = ImageDataFormat.Dat;
                            break;
                        case ".rpt":
                            imageDataFormat = ImageDataFormat.Rpt;
                            break;
                        case ".inf":
                            imageDataFormat = ImageDataFormat.Inf;
                            break;

                        default:
                            result.ResultCode = OpResultCode.Error;
                            result.Message = $"{fileName} 文件格式不支持\n";
                            FileUtils.DeleteDirectory(tempFolderPath);
                            return result;
                    }
                    var md5 = byteData.ToMd5();
                    var ventilatorChild = new VentilatorChild
                    {
                        Format = imageDataFormat,
                        OriginalName = fileName,
                        HashCode = md5,
                    };
                    if (ventilatorFile.Children.Any(x => x.Format == imageDataFormat))
                    {
                        result.ResultCode = OpResultCode.Error;
                        result.Message = $"{imageDataFormat}文件存在重复！\n";
                        FileUtils.DeleteDirectory(tempFolderPath);
                        return result;
                    }
                    ventilatorFile.Children.Add(ventilatorChild);
                    FileUtils.ByteToFile(tempFolderPath, fileName, byteData);
                    var analyisFileName = fileName + CommonConfigManager.VentilatorAnalysisFileExtension;
                    var analyisFilePath = Path.Combine(tempFolderPath, analyisFileName);
                    switch (imageDataFormat)
                    {
                        case ImageDataFormat.Rpt:
                            AnalyisRptFile(analyisFilePath, byteData, out var sn, out var modeNumber, out var startTime);
                            ventilatorFile.DeviceSN = sn.Replace("\0", "");
                            ventilatorFile.Mode = EnumHelper.GetEnumByIndex<DeviceMode>(modeNumber);
                            ventilatorFile.TreatTime = DateTimeOffset.FromUnixTimeSeconds(startTime + CommonConfigManager.VentilatorTimeStampConvertParameter).UtcDateTime;
                            ventilatorFile.FolderName = DateTimeOffset.FromUnixTimeSeconds(startTime + CommonConfigManager.VentilatorTimeStampConvertParameter).LocalDateTime.ToString("yyyyMMdd");
                            var getIOTDeviceUsersRequest = new GetIOTDeviceUsersRequest
                            {
                                Token = CommonConfigManager.DefaultTokenForFlyinsonoHealthServer,
                                DeviceSNList = new List<string>()
                                {
                                    ventilatorFile.DeviceSN
                                }
                            };
                            var deviceUserListDTO = await JsonRpcHelper.GetIOTDeviceUserListAsync(getIOTDeviceUsersRequest);
                            if (deviceUserListDTO == null || deviceUserListDTO.Count == 0)
                            {
                                result.ResultCode = OpResultCode.Error;
                                result.Message = $"上传失败，设备{ventilatorFile.DeviceSN}未绑定用户信息！\n";
                                FileUtils.DeleteDirectory(tempFolderPath);
                                return result;
                            }
                            else
                            {
                                var user = deviceUserListDTO.FirstOrDefault();
                                if (user.UserDataList == null || user.UserDataList.Count == 0)
                                {
                                    result.ResultCode = OpResultCode.Error;
                                    result.Message = $"上传失败，设备{ventilatorFile.DeviceSN}未绑定用户信息！\n";
                                    FileUtils.DeleteDirectory(tempFolderPath);
                                    return result;
                                }
                                else
                                {
                                    ventilatorFile.DeviceMac = user.DeviceMAC;
                                    var userData = user.UserDataList.FirstOrDefault();
                                    ventilatorFile.UserInfo = new UserInfo
                                    {
                                        UserId = userData.UserCode,
                                        Name = userData.Name,
                                        Age = userData.Age,
                                        Sex = EnumHelper.GetEnumByIndex<SexType>(userData.Gender),
                                        BMI = userData.BMI,
                                        BMIString = userData.BMI.ToString(),
                                        Height = userData.Height,
                                        Weight = userData.Weight,
                                        Neck = userData.Neck,
                                    };
                                }
                            }
                            var userCode = ventilatorFile.UserInfo?.UserId;
                            var exist = await ventilatorFileDataManager.GetVentilatorFileAsync(organizationId, ventilatorFile.DeviceSN, ventilatorFile.TreatTime, fileName);
                            if (exist != null)
                            {
                                result.ResultCode = OpResultCode.Error;
                                result.Message = $"文件已经上传，请勿重复上传！\n";
                                FileUtils.DeleteDirectory(tempFolderPath);
                            }
                            break;

                        case ImageDataFormat.Evt:
                            AnalyisEvtFile(analyisFilePath, byteData);
                            break;

                        case ImageDataFormat.Dat:
                            AnalyisDatFile(analyisFilePath, byteData);
                            break;
                        case ImageDataFormat.Inf:
                            AnalyisInfFile(analyisFilePath, byteData);
                            break;
                    }
                    result.VentilatorFile = ventilatorFile;
                    return result;
                }
            }
            result.ResultCode = OpResultCode.InvalidSession;
            result.Message = $"登录时效已过期，请重新登录。\n";
            return result;
        }

        /// <summary>
        /// 上传原始数据并解析.
        /// </summary>
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <returns>Void</returns>
        public async Task<OpResult> UploadUnLabeledVentilatorFileAsync(long sessionId, VentilatorFile ventilatorFile)
        {
            var result = new VentilatorOpResult() { ResultCode = OpResultCode.Success };
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    int version = 0;
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    var ventilatorFileVersionDataManager = databaseService.GetManager<IVentilatorFileVersionDataManager>();
                    var tempFolderPath = Path.Combine(CommonConfigManager.VentilatorTransformTempFolder, ventilatorFile.Id.ToString());
                    var folderPath = Path.Combine(CommonConfigManager.VentilatorTransformFolder, ventilatorFile.Id.ToString(), version.ToString());
                    try
                    {
                        foreach (var child in ventilatorFile.Children)
                        {
                            var filePath = Path.Combine(tempFolderPath, child.OriginalName);
                            if (!File.Exists(filePath))
                            {
                                result.Message = $"{child.OriginalName} 上传失败!\n";
                                result.ResultCode = OpResultCode.Error;
                                FileUtils.DeleteDirectory(tempFolderPath);
                                return result;
                            }
                            var fileData = FileUtils.ReadBytesFromFile(filePath);
                            var userCode = ventilatorFile.UserInfo?.UserId;
                            var saveIOTDeviceDataRequest = new SaveIOTDeviceDataRequest
                            {
                                TreatTime = ventilatorFile.TreatTime,
                                DataDesc = "",
                                FileData = fileData,
                                FolderName = ventilatorFile.FolderName,
                                OriginalFileName = child.OriginalName,
                                DeviceSN = ventilatorFile.DeviceSN,
                                Token = CommonConfigManager.DefaultTokenForFlyinsonoHealthServer,
                                DeviceMac = ventilatorFile.DeviceMac,
                                UserCode = userCode,
                            };
                            var fileUrl = await JsonRpcHelper.SaveIOTDeviceDataAsync(saveIOTDeviceDataRequest);
                            if (string.IsNullOrEmpty(fileUrl))
                            {
                                result.ResultCode = OpResultCode.Error;
                                result.Message = $"{child.OriginalName}  云平台保存设备用户原始数据失败。\n";
                                FileUtils.DeleteDirectory(tempFolderPath);
                                return result;
                            }
                            else
                            {
                                child.FileUrl = fileUrl;
                            }
                            FileUtils.DeleteFile(filePath);
                        }

                        FileUtils.CopyDirectoryContent(tempFolderPath, folderPath);
                        FileUtils.DeleteDirectory(tempFolderPath);
                        var utcNow = DateTime.UtcNow;
                        var ventilatorFileVersion = new VentilatorFileVersion()
                        {
                            VentilatorFileId = ventilatorFile.Id,
                            Version = version,
                            Message = $"{session.Name}上传了数据。",
                            CreateTime = utcNow,
                        };
                        ventilatorFile.CreateTime = utcNow;
                        ventilatorFile.UpdateTime = utcNow;
                        await ventilatorFileVersionDataManager.CreateVentilatorFileVersionAsync(ventilatorFileVersion);
                        await ventilatorFileDataManager.CreateVentilatorFileAsync(ventilatorFile);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} add un-labeled ventilator file name {ventilatorFile.Name} and sn {ventilatorFile.DeviceSN}.");
                        return result;
                    }
                    catch (Exception ex)
                    {
                        result.Message = $"上传失败!\n";
                        result.ResultCode = OpResultCode.Error;
                        Logger.WriteLineError($"上传失败,SN:{ventilatorFile.DeviceSN},FolderName:{ventilatorFile.FolderName},文件组:{Path.GetFileNameWithoutExtension(ventilatorFile.Children.FirstOrDefault()?.OriginalName)},{ex}");
                        FileUtils.DeleteDirectory(tempFolderPath);
                        FileUtils.DeleteDirectory(folderPath);
                        return result;
                    }
                }
            }
            result.ResultCode = OpResultCode.InvalidSession;
            result.Message = $"登录时效已过期，请重新登录。";
            return result;
        }

        /// <summary>
        /// 获取呼吸文件数量
        /// </summary>
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <returns></returns>
        public async Task<int> GetVentilatorFilesCountAsync(long sessionId, SearchVentilatorFileModel searchModel)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    var count = await ventilatorFileDataManager.GetVentilatorFilesCountAsync(searchModel);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get ventilator files Count.");
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// 获取呼吸文件.
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <param name="pageIndex">The index of page.</param>
        /// <param name="pageSize">The item count per page.</param>
        /// </summary>
        public async Task<List<VentilatorFile>> GetVentilatorFilesAsync(long sessionId, int pageIndex, int pageSize, SearchVentilatorFileModel searchModel)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    return await ventilatorFileDataManager.GetVentilatorFilesAsync(pageIndex, pageSize, searchModel);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the VentilatorFile
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="ventilatorFileId"></param>
        /// <returns></returns>
        public async Task<VentilatorFile> GetVentilatorFileByIdAsync(long sessionId, long ventilatorFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    var result = await ventilatorFileDataManager.GetVentilatorFileByIdAsync(ventilatorFileId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get ventilator file by id {ventilatorFileId}.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidLabelerSession");
        }

        /// <summary>
        /// update the VentilatorFile
        /// </summary>
        /// <param name="sessionId"></param>
        /// <param name="ventilatorFile"></param>
        /// <returns></returns>
        public async Task UpdateVentilatorFileByIdAsync(long sessionId, VentilatorFile ventilatorFile)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    await ventilatorFileDataManager.UpdateVentilatorFileAsync(ventilatorFile);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} update ventilator file by id {ventilatorFile.Id}.");
                    return;
                }
            }
            throw new InvalidOperationException("InvalidLabelerSession");
        }

        /// <summary>
        /// Download the Ventilator Files
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="ventilatorIdList"></param>
        /// <param name="deviceParameterList"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<byte[]> DownloadVentilatorFilesAsync(long sessionId, List<long> ventilatorIdList, List<DeviceParameter> deviceParameterList)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    var tempFolderPath = Path.Combine(CommonConfigManager.VentilatorTempDownloadFolder, sessionId.ToString());
                    FileUtils.DeleteDirectory(tempFolderPath);
                    var destZipName = $"VentilatorDownload_{sessionId}_{DateTime.Now.ToString("yyyyMMddHHmmss")}.zip";
                    var destZipPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, destZipName);
                    foreach (var ventilatorId in ventilatorIdList)
                    {
                        var ventilatorFile = await ventilatorFileDataManager.GetVentilatorFileByIdAsync(ventilatorId);
                        string originFolderPath;
                        var destFolderPath = Path.Combine(tempFolderPath, $"{ventilatorFile.Id}_{ventilatorFile.DeviceSN}_{ventilatorFile.FolderName}");
                        FileUtils.CreateDirectory(destFolderPath);
                        if (ventilatorFile.State == LabelState.Unlabeled)
                        {
                            originFolderPath = Path.Combine(CommonConfigManager.VentilatorTransformFolder, ventilatorFile.Id.ToString(), ventilatorFile.LatestFileVersion.ToString());
                        }
                        else
                        {
                            originFolderPath = Path.Combine(CommonConfigManager.LabeledVentilatorFolder, ventilatorFile.Id.ToString(), ventilatorFile.LatestFileVersion.ToString());
                        }
                        foreach (var child in ventilatorFile.Children)
                        {
                            var filePath = Path.Combine(originFolderPath, child.OriginalName + CommonConfigManager.VentilatorAnalysisFileExtension);
                            var destFilePath = Path.Combine(destFolderPath, child.OriginalName + CommonConfigManager.VentilatorAnalysisFileExtension);
                            switch (child.Format)
                            {
                                case ImageDataFormat.Evt:
                                    if (File.Exists(filePath))
                                    {
                                        File.Copy(filePath, destFilePath);
                                    }
                                    break;
                                case ImageDataFormat.Dat:
                                    if (File.Exists(filePath))
                                    {
                                        if (deviceParameterList.Contains(DeviceParameter.Pressure) && deviceParameterList.Contains(DeviceParameter.Airflow))
                                        {
                                            File.Copy(filePath, destFilePath);
                                        }
                                        else if (deviceParameterList.Contains(DeviceParameter.Pressure) || deviceParameterList.Contains(DeviceParameter.Airflow))
                                        {
                                            List<VentilatorDatInfo> ventilatorDatInfos = new List<VentilatorDatInfo>();
                                            using (StreamReader reader = new StreamReader(filePath))
                                            {
                                                string line;
                                                int pressure = 0;
                                                int airflow = 0;
                                                reader.ReadLine();
                                                while ((line = reader.ReadLine()) != null)
                                                {
                                                    var data = line.Split(',');
                                                    if (data.Length == 2)
                                                    {
                                                        int.TryParse(data[0], out pressure);
                                                        int.TryParse(data[1], out airflow);
                                                        ventilatorDatInfos.Add(new VentilatorDatInfo(pressure, airflow));
                                                    }
                                                }
                                            }
                                            using (StreamWriter writer = new StreamWriter(destFilePath, false))
                                            {
                                                if (deviceParameterList.Contains(DeviceParameter.Pressure))
                                                {
                                                    writer.WriteLine(EnumHelper.GetEnumDescription(DeviceParameter.Pressure));
                                                    foreach (var dat in ventilatorDatInfos)
                                                    {
                                                        writer.WriteLine($"{dat.Pressure}");
                                                    }
                                                }
                                                else
                                                {
                                                    writer.WriteLine(EnumHelper.GetEnumDescription(DeviceParameter.Airflow));
                                                    foreach (var dat in ventilatorDatInfos)
                                                    {
                                                        writer.WriteLine($"{dat.Airflow}");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;

                                case ImageDataFormat.Inf:
                                    if (File.Exists(filePath))
                                    {
                                        if (deviceParameterList.Contains(DeviceParameter.TidalVolume)
                                            && deviceParameterList.Contains(DeviceParameter.BPM)
                                            && deviceParameterList.Contains(DeviceParameter.MinuteVentilation)
                                            && deviceParameterList.Contains(DeviceParameter.Leakage)
                                            && deviceParameterList.Contains(DeviceParameter.Phase)
                                            && deviceParameterList.Contains(DeviceParameter.InhTime)
                                            && deviceParameterList.Contains(DeviceParameter.SpO2)
                                            && deviceParameterList.Contains(DeviceParameter.PulseRate)
                                            && deviceParameterList.Contains(DeviceParameter.MaxPressure)
                                            && deviceParameterList.Contains(DeviceParameter.MaxFlow))
                                        {
                                            File.Copy(filePath, destFilePath);
                                        }
                                        else if (deviceParameterList.Any(x => x == DeviceParameter.TidalVolume
                                        || x == DeviceParameter.BPM
                                        || x == DeviceParameter.MinuteVentilation
                                        || x == DeviceParameter.Leakage
                                        || x == DeviceParameter.Phase
                                        || x == DeviceParameter.InhTime
                                        || x == DeviceParameter.SpO2
                                        || x == DeviceParameter.PulseRate
                                        || x == DeviceParameter.MaxPressure
                                        || x == DeviceParameter.MaxFlow))
                                        {
                                            List<VentilatorInfInfo> ventilatorInfInfos = new List<VentilatorInfInfo>();
                                            using (StreamReader reader = new StreamReader(filePath))
                                            {
                                                string line;
                                                int tidalVolume = 0;
                                                int bpm = 0;
                                                int minuteVentilation = 0;
                                                int leakage = 0;
                                                int phase = 0;
                                                int inhTime = 0;
                                                int spO2 = 0;
                                                int pulseRate = 0;
                                                int maxPressure = 0;
                                                int maxFlow = 0;
                                                reader.ReadLine();
                                                while ((line = reader.ReadLine()) != null)
                                                {
                                                    var data = line.Split(',');
                                                    if (data.Length == 10)
                                                    {
                                                        int.TryParse(data[0], out tidalVolume);
                                                        int.TryParse(data[1], out bpm);
                                                        int.TryParse(data[2], out minuteVentilation);
                                                        int.TryParse(data[3], out leakage);
                                                        int.TryParse(data[4], out phase);
                                                        int.TryParse(data[5], out inhTime);
                                                        int.TryParse(data[6], out spO2);
                                                        int.TryParse(data[7], out pulseRate);
                                                        int.TryParse(data[8], out maxPressure);
                                                        int.TryParse(data[9], out maxFlow);
                                                        ventilatorInfInfos.Add(new VentilatorInfInfo(tidalVolume, bpm, minuteVentilation, leakage, phase, inhTime, spO2, pulseRate, maxPressure, maxFlow));
                                                    }
                                                }
                                                string firstLine = string.Empty;
                                                foreach (var deviceParameter in Enum.GetValues(typeof(DeviceParameter)))
                                                {
                                                    var dP = (DeviceParameter)deviceParameter;
                                                    if (deviceParameterList.Contains(dP))
                                                    {
                                                        if (dP == DeviceParameter.Pressure || dP == DeviceParameter.Airflow)
                                                        {
                                                            continue;
                                                        }
                                                        else
                                                        {
                                                            firstLine += EnumHelper.GetEnumDescription(dP) + ',';
                                                        }
                                                    }
                                                }
                                                firstLine = firstLine[..^1];
                                                using (StreamWriter writer = new StreamWriter(destFilePath, false))
                                                {
                                                    writer.WriteLine(firstLine);
                                                    foreach (var dat in ventilatorInfInfos)
                                                    {
                                                        string nextLine = string.Empty;
                                                        foreach (var deviceParameter in Enum.GetValues(typeof(DeviceParameter)))
                                                        {
                                                            var dP = (DeviceParameter)deviceParameter;
                                                            if (deviceParameterList.Contains(dP))
                                                            {
                                                                switch (dP)
                                                                {
                                                                    case DeviceParameter.TidalVolume:

                                                                        nextLine += dat.TidalVolume.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.BPM:
                                                                        nextLine += dat.BPM.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.MinuteVentilation:
                                                                        nextLine += dat.MinuteVentilation.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.Leakage:
                                                                        nextLine += dat.Leakage.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.Phase:
                                                                        nextLine += dat.Phase.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.InhTime:
                                                                        nextLine += dat.InhTime.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.SpO2:
                                                                        nextLine += dat.SpO2.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.PulseRate:
                                                                        nextLine += dat.PulseRate.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.MaxPressure:
                                                                        nextLine += dat.MaxPressure.ToString() + ',';
                                                                        break;

                                                                    case DeviceParameter.MaxFlow:
                                                                        nextLine += dat.MaxFlow.ToString() + ',';
                                                                        break;
                                                                }
                                                            }
                                                        }
                                                        nextLine = nextLine[..^1];
                                                        writer.WriteLine($"{nextLine}");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                            }
                        }
                    }
                    ZipFile.CreateFromDirectory(tempFolderPath, destZipPath);
                    FileUtils.DeleteDirectory(tempFolderPath);
                    var buffer = FileUtils.ReadBytesFromFile(destZipPath);
                    FileUtils.DeleteFile(destZipPath);
                    return buffer;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get the VentilatorFileVersion count.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="ventilatorFileId">The id of the ventilator file.</param>
        /// <returns>The count of the VentilatorFileVersion.</returns>
        public async Task<int> GetVentilatorFileVersionCountAsync(long sessionId, long ventilatorFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileVersionDataManager = databaseService.GetManager<IVentilatorFileVersionDataManager>();
                    var count = await ventilatorFileVersionDataManager.GetVentilatorFileVersionCountAsync(ventilatorFileId);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get ventilator file versions count.");
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }
        /// <summary>
        /// Get VentilatorFileVersion items.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="pageIndex">The index of the page.</param>
        /// <param name="pageSize">The size of the page.</param>
        /// <returns>The loaded VentilatorFileVersions</returns>
        public async Task<List<VentilatorFileVersion>> GetVentilatorFileVersionsAsync(long sessionId, long ventilatorFileId, int pageIndex, int pageSize)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileVersionDataManager = databaseService.GetManager<IVentilatorFileVersionDataManager>();
                    return await ventilatorFileVersionDataManager.GetVentilatorFileVersionsAsync(ventilatorFileId, pageIndex, pageSize);
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// 删除呼吸文件.
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <param name="ventilatorFileId">The ventilator file id</param>
        /// </summary>
        public async Task DeleteVentilatorFileByIdAsync(long sessionId, long ventilatorFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
                    var ventilatorFileVersionDataManager = databaseService.GetManager<IVentilatorFileVersionDataManager>();
                    var ventilatorFile = await ventilatorFileDataManager.GetVentilatorFileByIdAsync(ventilatorFileId);
                    if (ventilatorFile != null)
                    {
                        var latestVersion = ventilatorFile.LatestFileVersion + 1;
                        var ventilatorFileVersion = new VentilatorFileVersion()
                        {
                            VentilatorFileId = ventilatorFile.Id,
                            Version = latestVersion,
                            Message = $"{session.Name}删除了数据。"
                        };
                        await ventilatorFileVersionDataManager.CreateVentilatorFileVersionAsync(ventilatorFileVersion);
                        ventilatorFile.IsDeleted = true;
                        ventilatorFile.LatestFileVersion = latestVersion;
                        await ventilatorFileDataManager.DeleteVentilatorFileAsync(ventilatorFile);
                        await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted ventilator file id {ventilatorFileId}.");
                    }
                    return;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// 同步呼吸文件.
        /// <param name="sessionId">The sessionId of the admin</param>
        /// <param name="organziationId">organziation id</param>
        /// </summary>
        public async Task<OpResult> SyncVentilatorFilesAsync(long sessionId, long organziationId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    return await SyncVentilatorFilesAsync(organziationId);
                }
            }
            return new OpResult { ResultCode = OpResultCode.InvalidSession, Message = $"登录时效已过期，请重新登录。" };
        }

        /// <summary>
        /// 获取呼吸机参数信息
        /// </summary>
        /// <param name="sessionId"></param>
        /// <returns></returns>
        public async Task<VentilatorParameterInfo> GetVentilatorParameterInfoByIdAsync(long sessionId, long ventilatorFileId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    VentilatorParameterInfo ventilatorParameterInfo = new VentilatorParameterInfo();
                    var originFolderPath = Path.Combine(CommonConfigManager.VentilatorTransformFolder, ventilatorFileId.ToString(), "0");
                    var rptFiles = Directory.GetFiles(originFolderPath, "*.rpt" + CommonConfigManager.VentilatorAnalysisFileExtension);

                    try
                    {
                        if (rptFiles.Length > 0)
                        {
                            var rptFile = rptFiles[0];
                            using (StreamReader reader = new StreamReader(rptFile))
                            {
                                reader.ReadLine();//ConfigurationInfo
                                reader.ReadLine();//SN
                                reader.ReadLine();//SN Number
                                reader.ReadLine();//Mode,StartPressure,TreatPressure,MinPressure,MaxPressure,Pressure_sense,MinEPAP,MaxIPAP
                                var values = reader.ReadLine().Split(',');
                                if (values.Length == 8)
                                {
                                    ventilatorParameterInfo.Mode = EnumHelper.GetEnumByIndex<DeviceMode>(int.Parse(values[0]));
                                    ventilatorParameterInfo.StartPressure = values[1];
                                    ventilatorParameterInfo.TreatPressure = values[2];
                                    ventilatorParameterInfo.MinPressure = values[3];
                                    ventilatorParameterInfo.MaxPressure = values[4];
                                    ventilatorParameterInfo.PressureSense = values[5];
                                    ventilatorParameterInfo.MinEPAP = values[6];
                                    ventilatorParameterInfo.MaxIPAP = values[7];
                                }
                                else
                                {
                                    throw new InvalidOperationException("VentilatorParameterAnalyisFail");
                                }
                                reader.ReadLine();//PS,IPAP,EPAP,P_risetime,Min_inhtime,Max_inhtime,inh_sense,exp_sense
                                values = reader.ReadLine().Split(',');
                                if (values.Length == 8)
                                {
                                    ventilatorParameterInfo.PS = values[0];
                                    ventilatorParameterInfo.IPAP = values[1];
                                    ventilatorParameterInfo.EPAP = values[2];
                                    ventilatorParameterInfo.PRisetime = values[3];
                                    ventilatorParameterInfo.MinInhTime = values[4];
                                    ventilatorParameterInfo.MaxInhTime = values[5];
                                    ventilatorParameterInfo.InhSense = values[6];
                                    ventilatorParameterInfo.ExpSense = values[7];
                                }
                                else
                                {
                                    return null;
                                }
                                reader.ReadLine();//Backup_Vent,BPM,inh_time,TargetV_Switch,TargetV,TargetV_minIPAP,TargetV_maxIPAP,AutoStart
                                values = reader.ReadLine().Split(',');
                                if (values.Length == 8)
                                {
                                    ventilatorParameterInfo.BackupVent = values[0];
                                    ventilatorParameterInfo.BPM = values[1];
                                    ventilatorParameterInfo.InhTime = values[2];
                                    ventilatorParameterInfo.TargetVSwitch = values[3];
                                    ventilatorParameterInfo.TargetV = values[4];
                                    ventilatorParameterInfo.TargetVMinIPAP = values[5];
                                    ventilatorParameterInfo.TargetVMaxIPAP = values[6];
                                    ventilatorParameterInfo.AutoStart = values[7];
                                }
                                else
                                {
                                    throw new InvalidOperationException("VentilatorParameterAnalyisFail");
                                }
                                reader.ReadLine();//AutoStop,Humi_Level,Tube_Level,Raise_Level,Exp_Decrease_Level
                                values = reader.ReadLine().Split(',');
                                if (values.Length >= 5)
                                {
                                    ventilatorParameterInfo.AutoStop = values[0];
                                    ventilatorParameterInfo.Humi_Level = values[1];
                                    ventilatorParameterInfo.Tube_Level = values[2];
                                    ventilatorParameterInfo.Raise_Level = values[3];
                                    ventilatorParameterInfo.Exp_Decrease_Level = values[4];
                                }
                                else
                                {
                                    throw new InvalidOperationException("VentilatorParameterAnalyisFail");
                                }
                                return ventilatorParameterInfo;
                            }
                        }
                        throw new InvalidOperationException("VentilatorParameterAnalyisFail");
                    }
                    catch
                    {
                        throw new InvalidOperationException("VentilatorParameterAnalyisFail");
                    }
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        internal async Task<OpResult> SyncVentilatorFilesAsync(long organziationId)
        {
            string msg = "";
            var databaseService = ServiceManager.GetService<IDatabaseService>();
            var ventilatorImportInfoDataManager = databaseService.GetManager<IVentilatorImportInfoDataManager>();
            var ventilatorFileDataManager = databaseService.GetManager<IVentilatorFileDataManager>();
            var ventilatorFileVersionDataManager = databaseService.GetManager<IVentilatorFileVersionDataManager>();
            var utcNow = DateTime.UtcNow;
            var ventilatorFileList = new List<VentilatorFile>();
            var ventilatorImportInfo = await ventilatorImportInfoDataManager.GetVentilatorImportInfoByOrganizationIdAsync(organziationId);
            if (ventilatorImportInfo == null)
            {
                ventilatorImportInfo = new VentilatorImportInfo()
                {
                    OrganizationId = organziationId,
                    LastImportTime = new DateTime(2000, 1, 1)
                };
                await ventilatorImportInfoDataManager.CreateVentilatorImportInfoAsync(ventilatorImportInfo);
            }
            if (ventilatorImportInfo.LastImportTime <= utcNow)
            {
                var getIOTDeviceFileDataRequest = new GetIOTDeviceFileDataRequest
                {
                    CreateTimeFrom = ventilatorImportInfo.LastImportTime.AddDays(-1),
                    CreateTimeTo = utcNow.AddDays(1),
                    Token = CommonConfigManager.DefaultTokenForFlyinsonoHealthServer,
                };
                var deviceDataList = await JsonRpcHelper.GetIOTDeviceDataListAsync(getIOTDeviceFileDataRequest);
                if (deviceDataList == null)
                {
                    return new OpResult { ResultCode = OpResultCode.Error, Message = "拉取数据失败，服务器无响应。" };
                }
                else
                {
                    if (deviceDataList.Count > 0)
                    {
                        foreach (var deviceData in deviceDataList)
                        {
                            string deviceSN = deviceData.DeviceSN;
                            string deviceMac = deviceData.DeviceMAC;
                            if (deviceData.UserDataList != null && deviceData.UserDataList.Count > 0)
                            {
                                foreach (var userData in deviceData.UserDataList)
                                {
                                    var userInfo = new UserInfo
                                    {
                                        UserId = userData.UserCode,
                                        Name = userData.Name,
                                        Age = userData.Age,
                                        Sex = EnumHelper.GetEnumByIndex<SexType>(userData.Gender),
                                        BMI = userData.BMI,
                                        BMIString = userData.BMI.ToString(),
                                        Height = userData.Height,
                                        Weight = userData.Weight,
                                        Neck = userData.Neck
                                    };
                                    if (userData.FolderList != null && userData.FolderList.Count > 0)
                                    {
                                        foreach (var folder in userData.FolderList)
                                        {
                                            var folderName = folder.FolderName;
                                            var ventilatorFolderInfos = SortDataFileList(folder.DataFileList, folderName, deviceSN);
                                            if (ventilatorFolderInfos != null && ventilatorFolderInfos.Count > 0)
                                            {
                                                foreach (var ventilatorFolderInfo in ventilatorFolderInfos)
                                                {
                                                    VentilatorFile ventilatorFile = ConvertVentilatorFolderInfoToVentilatorFile(ventilatorFolderInfo, userInfo, organziationId, deviceMac);
                                                    if (ventilatorFile != null)
                                                    {
                                                        ventilatorFileList.Add(ventilatorFile);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                return new OpResult { ResultCode = OpResultCode.Success, Message = msg };
            }
            if (ventilatorFileList.Count > 0)
            {
                foreach (var ventilatorFile in ventilatorFileList)
                {
                    bool isDuplicated = false;
                    if (ventilatorFile.Children == null || ventilatorFile.Children.Count != 4)
                    {
                        continue;
                    }
                    var firstFileName = ventilatorFile.Children.FirstOrDefault().OriginalName;
                    var tempFolderPath = Path.Combine(CommonConfigManager.VentilatorTransformTempFolder, ventilatorFile.Id.ToString());
                    int version = 0;
                    var folderPath = Path.Combine(CommonConfigManager.VentilatorTransformFolder, ventilatorFile.Id.ToString(), version.ToString());
                    try
                    {
                        FileUtils.DeleteDirectory(tempFolderPath);
                        foreach (var child in ventilatorFile.Children)
                        {
                            var filePath = Path.Combine(tempFolderPath, child.OriginalName);
                            var analyisFileName = child.OriginalName + CommonConfigManager.VentilatorAnalysisFileExtension;
                            var analyisFilePath = Path.Combine(tempFolderPath, analyisFileName);
                            DownloadHelper.GetFile(child.FileUrl, filePath);
                            var byteData = FileUtils.ReadBytesFromFile(filePath);
                            if (byteData == null || byteData.Length == 0)
                            {
                                var errorMsg = $"Download FileToken Failed. FileToken:{child.FileUrl}, DeviceSN:{ventilatorFile.DeviceSN}, FolderName:{ventilatorFile.FolderName}, FileName:{child.OriginalName}";
                                Logger.WriteLineError(errorMsg);
                                msg += errorMsg + "\r\n";
                                return new OpResult { ResultCode = OpResultCode.Error, Message = msg };
                            }
                            child.HashCode = byteData.ToMd5();
                            switch (child.Format)
                            {
                                case ImageDataFormat.Rpt:
                                    AnalyisRptFile(analyisFilePath, byteData, out var sn, out var modeNumber, out var startTime);
                                    ventilatorFile.DeviceSN = sn.Replace("\0", "");
                                    ventilatorFile.Mode = EnumHelper.GetEnumByIndex<DeviceMode>(modeNumber);
                                    ventilatorFile.TreatTime = DateTimeOffset.FromUnixTimeSeconds(startTime + CommonConfigManager.VentilatorTimeStampConvertParameter).UtcDateTime;
                                    var exist = await ventilatorFileDataManager.GetVentilatorFileAsync(organziationId, ventilatorFile.DeviceSN, ventilatorFile.TreatTime, child.OriginalName);
                                    if (exist != null)
                                    {
                                        Logger.WriteLineWarn($"File already exist and skip it,DeviceSN:{ventilatorFile.DeviceSN},TreateTime:{ventilatorFile.TreatTime}, FileName:{child.OriginalName}");
                                        isDuplicated = true;
                                        break;
                                    }
                                    break;

                                case ImageDataFormat.Evt:
                                    AnalyisEvtFile(analyisFilePath, byteData);
                                    break;

                                case ImageDataFormat.Dat:
                                    AnalyisDatFile(analyisFilePath, byteData);
                                    break;

                                case ImageDataFormat.Inf:
                                    AnalyisInfFile(analyisFilePath, byteData);
                                    break;
                            }
                            FileUtils.DeleteFile(filePath);
                            if (isDuplicated)
                            {
                                break;
                            }
                        }
                        if (isDuplicated)
                        {
                            FileUtils.DeleteDirectory(tempFolderPath);
                            continue;
                        }
                        FileUtils.CopyDirectoryContent(tempFolderPath, folderPath);
                        FileUtils.DeleteDirectory(tempFolderPath);
                        var createTime = DateTime.UtcNow;
                        ventilatorFile.CreateTime = createTime;
                        ventilatorFile.UpdateTime = createTime;
                        var ventilatorFileVersion = new VentilatorFileVersion()
                        {
                            VentilatorFileId = ventilatorFile.Id,
                            Version = version,
                            Message = $"系统同步了数据。",
                            CreateTime = createTime,
                        };
                        await ventilatorFileDataManager.CreateVentilatorFileAsync(ventilatorFile);
                        await ventilatorFileVersionDataManager.CreateVentilatorFileVersionAsync(ventilatorFileVersion);
                    }
                    catch (Exception ex)
                    {
                        var errorMsg = $"呼吸机同步失败,设备序列号:{ventilatorFile.DeviceSN}, 文件夹名称:{ventilatorFile.FolderName},文件组:{Path.GetFileNameWithoutExtension(ventilatorFile.Children.FirstOrDefault()?.OriginalName)}:{ex}";
                        Logger.WriteLineError(errorMsg);
                        msg += errorMsg + "\r\n";
                        FileUtils.DeleteDirectory(tempFolderPath);
                        FileUtils.DeleteDirectory(folderPath);
                    }
                }
            }
            ventilatorImportInfo.LastImportTime = utcNow;
            await ventilatorImportInfoDataManager.UpdateVentilatorImportInfoAsync(ventilatorImportInfo);
            return new OpResult { ResultCode = OpResultCode.Success, Message = msg };
        }

        private VentilatorFile ConvertVentilatorFolderInfoToVentilatorFile(VentilatorFolderInfo ventilatorFolderInfo, UserInfo userInfo, long organizationId, string deviceMac)
        {
            if (ventilatorFolderInfo == null)
            {
                return null;
            }
            if (ventilatorFolderInfo.FileDataList == null)
            {
                return null;
            }
            List<VentilatorChild> ventilatorChildren = new List<VentilatorChild>();
            foreach (var fileData in ventilatorFolderInfo.FileDataList)
            {
                var ventilatorChild = new VentilatorChild
                {
                    Format = fileData.Format,
                    OriginalName = fileData.OriginalName,
                    FileUrl = fileData.FileToken//临时存放FileToken
                };
                ventilatorChildren.Add(ventilatorChild);
            }
            return new VentilatorFile
            {
                OrganizationId = organizationId,
                DeviceSN = ventilatorFolderInfo.DeviceSN,
                DeviceMac = deviceMac,
                UserInfo = userInfo ?? new UserInfo(),
                State = LabelState.Unlabeled,
                FolderName = ventilatorFolderInfo.FolderName,
                Children = ventilatorChildren
            };
        }

        private List<VentilatorFolderInfo> SortDataFileList(IList<IOTDeviceFileDataRecordDTO> dataFileList, string folderName, string deviceSN)
        {
            var ventilatorFolderInfoList = new List<VentilatorFolderInfo>();
            if (dataFileList != null)
            {
                foreach (var dataFile in dataFileList)
                {
                    var fileName = dataFile.OriginalFileName;
                    var fileToken = dataFile.FileToken;
                    var extension = Path.GetExtension(fileName);
                    ImageDataFormat imageDataFormat = ImageDataFormat.RawData;
                    switch (extension.ToLower())
                    {
                        case ".evt":
                            imageDataFormat = ImageDataFormat.Evt;
                            break;
                        case ".dat":
                            imageDataFormat = ImageDataFormat.Dat;
                            break;
                        case ".rpt":
                            imageDataFormat = ImageDataFormat.Rpt;
                            break;
                        case ".inf":
                            imageDataFormat = ImageDataFormat.Inf;
                            break;

                        default:
                            continue;
                    }
                    var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
                    var existItem = ventilatorFolderInfoList.FirstOrDefault(x => x.DeviceSN == deviceSN && x.FolderName == folderName && x.FileNameWithoutExtension == fileNameWithoutExtension);
                    if (existItem == null)
                    {
                        var ventilatorFolderInfo = new VentilatorFolderInfo
                        {
                            DeviceSN = deviceSN,
                            FolderName = folderName,
                            FileNameWithoutExtension = fileNameWithoutExtension,
                            FileDataList = new List<VentilatorFileInfo>
                            {
                                new VentilatorFileInfo
                                {
                                    Format= imageDataFormat,
                                    FileToken=fileToken,
                                    OriginalName=fileName,
                                }
                            }
                        };
                        ventilatorFolderInfoList.Add(ventilatorFolderInfo);
                    }
                    else
                    {
                        var existFile = existItem.FileDataList.FirstOrDefault(x => x.OriginalName == fileName);
                        if (existFile == null)
                        {
                            var ventilatorFileInfo = new VentilatorFileInfo
                            {
                                Format = imageDataFormat,
                                FileToken = fileToken,
                                OriginalName = fileName,
                            };
                            existItem.FileDataList.Add(ventilatorFileInfo);
                        }
                        else
                        {
                            Logger.WriteLineWarn($"DeviceSN:{deviceSN},FolderName:{folderName},FileName:{fileName} already exist and will replaced");
                            existFile.FileToken = fileToken;
                        }
                    }
                }
            }
            return ventilatorFolderInfoList;
        }

        private void AnalyisRptFile(string analyisFilePath, byte[] byteData, out string sn, out int modeNumber, out int startTime)
        {
            using (var ms = new MemoryStream(byteData))
            {
                using (StreamWriter sw = new StreamWriter(analyisFilePath, false))
                {
                    using (BinaryReader br = new BinaryReader(ms))
                    {
                        var databuf = new byte[256];
                        byte[] sn_arr = new byte[16];
                        databuf = br.ReadBytes(256);

                        for (int i = 0; i < 16; i++)
                        {
                            sn_arr[i] = databuf[32 + i];
                        }
                        sn = Encoding.UTF8.GetString(sn_arr);

                        modeNumber = databuf[65] * 256 + databuf[64];
                        startTime = databuf[147] * 16777216 + databuf[146] * 65536 + databuf[145] * 256 + databuf[144];
                        int osa_count = databuf[207] * 256 + databuf[206];
                        int csa_count = databuf[209] * 256 + databuf[208];
                        int ai_count = databuf[205] * 256 + databuf[204];
                        int hpnea_count = databuf[203] * 256 + databuf[202];
                        int ahi_count = databuf[201] * 256 + databuf[200];
                        int use_time = databuf[151] * 16777216 + databuf[150] * 65536 + databuf[149] * 256 + databuf[148];
                        int quality = databuf[225] * 256 + databuf[224];
                        int snore_count = databuf[213] * 256 + databuf[212];
                        int FL_count = databuf[223] * 256 + databuf[222];
                        int avg_spo2 = databuf[187] * 256 + databuf[186];
                        int min_spo2 = databuf[189] * 256 + databuf[188];
                        int avg_pr = databuf[191] * 256 + databuf[190];

                        int oai = osa_count * 360000 / use_time;
                        int cai = csa_count * 360000 / use_time;
                        int ai = ai_count * 360000 / use_time;
                        int hi = hpnea_count * 360000 / use_time;
                        int ahi = ahi_count * 360000 / use_time;
                        int snore_index = snore_count * 360000 / use_time;
                        int FL_index = FL_count * 360000 / use_time;

                        sw.WriteLine("Configuration Info");
                        sw.WriteLine("SN");
                        sw.WriteLine("{0}", sn);
                        sw.WriteLine("Mode,StartPressure,TreatPressure,MinPressure,MaxPressure,Pressure_sense,MinEPAP,MaxIPAP");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", modeNumber, databuf[67] * 256 + databuf[66], databuf[69] * 256 + databuf[68], databuf[71] * 256 + databuf[70], databuf[73] * 256 + databuf[72], databuf[75] * 256 + databuf[74], databuf[77] * 256 + databuf[76], databuf[79] * 256 + databuf[78]);
                        sw.WriteLine("PS,IPAP,EPAP,P_risetime,Min_inhtime,Max_inhtime,inh_sense,exp_sense");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", databuf[81] * 256 + databuf[80], databuf[83] * 256 + databuf[82], databuf[85] * 256 + databuf[84], databuf[87] * 256 + databuf[86], databuf[89] * 256 + databuf[88], databuf[91] * 256 + databuf[90], databuf[93] * 256 + databuf[92], databuf[95] * 256 + databuf[94]);
                        sw.WriteLine("Backup_Vent,BPM,inh_time,TargetV_Switch,TargetV,TargetV_minIPAP,TargetV_maxIPAP,AutoStart");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", databuf[97] * 256 + databuf[96], databuf[99] * 256 + databuf[98], databuf[101] * 256 + databuf[100], databuf[103] * 256 + databuf[102], databuf[105] * 256 + databuf[104], databuf[107] * 256 + databuf[106], databuf[109] * 256 + databuf[108], databuf[111] * 256 + databuf[110]);
                        sw.WriteLine("AutoStop,Humi_Level,Tube_Level,Raise_Level,Exp_Decrease_Level");
                        sw.WriteLine("{0},{1},{2},{3},{4}", (databuf[113] * 256 + databuf[112]), (databuf[115] * 256 + databuf[114]), (databuf[117] * 256 + databuf[116]), (databuf[119] * 256 + databuf[118]), (databuf[121] * 256 + databuf[120]));
                        sw.WriteLine(" ");
                        sw.WriteLine("Report");
                        sw.WriteLine("Starttime,Usetime,avg_CPAP,CPAP95,CPAP90,avg_IPAP");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5}", startTime, use_time, databuf[153] * 256 + databuf[152], databuf[155] * 256 + databuf[154], databuf[157] * 256 + databuf[156], databuf[159] * 256 + databuf[158]);
                        sw.WriteLine("IPAP95,IPAP90,avg_EPAP,EPAP95,EPAP90,avg_tidalvolume,tidalvolume95,avg_minute_vent");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", databuf[161] * 256 + databuf[160], databuf[163] * 256 + databuf[162], databuf[165] * 256 + databuf[164], databuf[167] * 256 + databuf[166], databuf[169] * 256 + databuf[168], databuf[171] * 256 + databuf[170], databuf[173] * 256 + databuf[172], databuf[175] * 256 + databuf[174]);
                        sw.WriteLine("minute_vent95,avg_inhtime,ratio_autoinh,ratio_autoexp,avg_BPM,avg_SPO2,min_SPO2,avg_pulserate");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", databuf[177] * 256 + databuf[176], databuf[179] * 256 + databuf[178], databuf[181] * 256 + databuf[180], databuf[183] * 256 + databuf[182], databuf[185] * 256 + databuf[184], avg_spo2 == 127 ? "/" : avg_spo2.ToString(), min_spo2 == 127 ? "/" : min_spo2.ToString(), avg_pr == 255 ? "/" : avg_pr.ToString());
                        sw.WriteLine("avg_leakage,leakage95,leakage90,ratio_highleakage,AHI_count,Hpnea_count,AI_count,OSA_count");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", databuf[193] * 256 + databuf[192], databuf[195] * 256 + databuf[194], databuf[197] * 256 + databuf[196], databuf[199] * 256 + databuf[198], ahi_count, hpnea_count, ai_count, osa_count);
                        sw.WriteLine("CSA_count,snore_coff_sum,snore_count,CSR_count,BIOT_count,RERA_count,FL_coff_sum,FL_count");
                        sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7}", csa_count, databuf[211] * 256 + databuf[210], snore_count, databuf[215] * 256 + databuf[214], databuf[217] * 256 + databuf[216], databuf[219] * 256 + databuf[218], databuf[221] * 256 + databuf[220], FL_count);
                        sw.WriteLine("treat_quality");
                        switch (quality)
                        {
                            case 0:
                                sw.WriteLine("Excellent(优秀)");
                                break;
                            case 1:
                                sw.WriteLine("Well(良好)");
                                break;
                            case 2:
                                sw.WriteLine("Common(一般)");
                                break;
                            case 3:
                                sw.WriteLine("Bad(不佳)");
                                break;
                            default:
                                break;
                        }
                        sw.WriteLine(" ");
                        sw.WriteLine("OAI,CAI,AI,HI,AHI,Snore_index,Flow_limit_index");
                        sw.WriteLine("{0}.{1},{2}.{3},{4}.{5},{6}.{7},{8}.{9},{10}.{11},{12}.{13}", oai / 100, oai % 100, cai / 100, cai % 100, ai / 100, ai % 100, hi / 100, hi % 100, ahi / 100, ahi % 100, snore_index / 100, snore_index % 100, FL_index / 100, FL_index % 100);
                    }
                }
            }
        }

        private static void AnalyisEvtFile(string analyisFilePath, byte[] byteData)
        {
            using (var ms = new MemoryStream(byteData))
            {
                using (StreamWriter sw = new StreamWriter(analyisFilePath, false))
                {
                    using (BinaryReader br = new BinaryReader(ms))
                    {
                        byte[] databuf = new byte[12];
                        byte[] headbuf = new byte[64];
                        int relative_time = 0;
                        UInt16 para = 0;
                        UInt16 event_type = 0;
                        headbuf = br.ReadBytes(64);

                        var startTime = headbuf[14] * 16777216 + headbuf[15] * 65536 + headbuf[16] * 256 + headbuf[17];
                        long store_cycle = (ms.Length - 64) / 12;
                        if (store_cycle == (headbuf[22] * 256 + headbuf[23]))
                        {
                            sw.WriteLine("Relative time,Duration/coefficient,Event type");
                            for (int i = 0; i < store_cycle; i++)
                            {
                                databuf = br.ReadBytes(12);
                                relative_time = databuf[5] * 16777216 + databuf[4] * 65536 + databuf[3] * 256 + databuf[2];
                                para = (UInt16)(databuf[7] * 256 + databuf[6]);
                                event_type = (UInt16)(databuf[9] * 256 + databuf[8]);
                                switch (event_type)
                                {
                                    case 0:
                                        sw.WriteLine("{0},{1},OSA", relative_time, para);
                                        break;
                                    case 1:
                                        sw.WriteLine("{0},{1},CSA", relative_time, para);
                                        break;
                                    case 2:
                                        sw.WriteLine("{0},{1},Hpnea", relative_time, para);
                                        break;
                                    case 3:
                                        sw.WriteLine("{0},{1},Flow Limit", relative_time, para);
                                        break;
                                    case 4:
                                        sw.WriteLine("{0},{1},Snore", relative_time, para);
                                        break;
                                    case 5:
                                        sw.WriteLine("{0},{1},CSR", relative_time, para);
                                        break;
                                    case 6:
                                        sw.WriteLine("{0},{1},BIOT", relative_time, para);
                                        break;
                                    case 7:
                                        sw.WriteLine("{0},{1},RERA", relative_time, para);
                                        break;
                                    default:
                                        sw.WriteLine("{0},{1},{2}", relative_time, para, event_type);
                                        break;
                                }
                            }
                        }
                    }
                }
            }
        }

        private void AnalyisDatFile(string analyisFilePath, byte[] byteData)
        {
            using (var ms = new MemoryStream(byteData))
            {
                using (StreamWriter sw = new StreamWriter(analyisFilePath, false))
                {
                    using (BinaryReader br = new BinaryReader(ms))
                    {
                        byte[] databuf = new byte[6004];
                        byte[] headbuf = new byte[64];
                        UInt16 pressure = 0;
                        UInt16 flow = 0;
                        headbuf = br.ReadBytes(64);
                        long store_cycle = (ms.Length - 64) / 6004;
                        if (store_cycle == (headbuf[22] * 256 + headbuf[23]))
                        {
                            sw.WriteLine("Pressure,Airflow");
                            for (int i = 0; i < store_cycle; i++)
                            {
                                databuf = br.ReadBytes(6004);
                                for (UInt16 j = 0; j < 1500; j++)
                                {
                                    pressure = (UInt16)(databuf[2 + 1 + 4 * j] * 256 + databuf[2 + 0 + 4 * j]);
                                    flow = (UInt16)(databuf[2 + 3 + 4 * j] * 256 + databuf[2 + 2 + 4 * j]);
                                    sw.WriteLine("{0},{1}", pressure, flow);
                                }
                            }
                        }
                    }
                }
            }
        }

        private void AnalyisInfFile(string analyisFilePath, byte[] byteData)
        {
            using (var ms = new MemoryStream(byteData))
            {
                using (StreamWriter sw = new StreamWriter(analyisFilePath, false))
                {
                    using (BinaryReader br = new BinaryReader(ms))
                    {
                        byte[] databuf = new byte[604];
                        byte[] headbuf = new byte[64];
                        UInt16 tidal_volume = 0;
                        UInt16 bpm = 0;
                        UInt16 minute_ventilation = 0;
                        UInt16 leakage = 0;
                        UInt16 phase = 0;
                        UInt16 inh_time = 0;
                        UInt16 spo2 = 0;
                        UInt16 pulse_rate = 0;
                        UInt16 max_pressure = 0;
                        UInt16 max_flow = 0;

                        headbuf = br.ReadBytes(64);

                        long store_cycle = (ms.Length - 64) / 604;
                        if (store_cycle == (headbuf[22] * 256 + headbuf[23]))
                        {
                            sw.WriteLine("Tidal Volume,BPM,Minute Ventilation,Leakage,Phase,Inh Time,SpO2,Pulse Rate,Max Pressure,Max Flow");
                            for (int i = 0; i < store_cycle; i++)
                            {
                                databuf = br.ReadBytes(604);
                                for (UInt16 j = 0; j < 30; j++)
                                {
                                    tidal_volume = (UInt16)(databuf[2 + 1 + 20 * j] * 256 + databuf[2 + 0 + 20 * j]);
                                    bpm = (UInt16)(databuf[2 + 3 + 20 * j] * 256 + databuf[2 + 2 + 20 * j]);
                                    minute_ventilation = (UInt16)(databuf[2 + 5 + 20 * j] * 256 + databuf[2 + 4 + 20 * j]);
                                    leakage = (UInt16)(databuf[2 + 7 + 20 * j] * 256 + databuf[2 + 6 + 20 * j]);
                                    phase = (UInt16)(databuf[2 + 9 + 20 * j] * 256 + databuf[2 + 8 + 20 * j]);
                                    inh_time = (UInt16)(databuf[2 + 11 + 20 * j] * 256 + databuf[2 + 10 + 20 * j]);
                                    spo2 = (UInt16)(databuf[2 + 13 + 20 * j] * 256 + databuf[2 + 12 + 20 * j]);
                                    pulse_rate = (UInt16)(databuf[2 + 15 + 20 * j] * 256 + databuf[2 + 14 + 20 * j]);
                                    max_pressure = (UInt16)(databuf[2 + 17 + 20 * j] * 256 + databuf[2 + 16 + 20 * j]);
                                    max_flow = (UInt16)(databuf[2 + 19 + 20 * j] * 256 + databuf[2 + 18 + 20 * j]);
                                    sw.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}", tidal_volume, bpm, minute_ventilation, leakage, phase, inh_time, spo2, pulse_rate, max_pressure, max_flow);
                                }
                            }
                        }
                    }
                }
            }
        }

        #endregion 呼吸机数据管理

        #region HandyToolClient

        /// <summary>
        /// Add one HandyTool client.
        /// </summary>
        /// <param name="version">The version of HandyTool client.</param>
        /// <param name="description">The description of HandyTool client.</param>
        /// <param name="clientData">The data of the HandyTool client.</param>
        /// <returns></returns>
        public async Task AddHandyToolClientAsync(long sessionId, string fileName, string version, string description, byte[] clientData)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var HandyToolClientDataManager = databaseService.GetManager<IHandyToolClientDataManager>();
                    var clientInfo = await HandyToolClientDataManager.GetHandyToolClientInfoAsync(version);
                    if (clientInfo != null)
                    {
                        throw new InvalidOperationException("SameVersionClientExist");
                    }
                    var defaultClientInfos = await HandyToolClientDataManager.GetDefaultHandyToolClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await HandyToolClientDataManager.SetUndefaultHandyToolClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo = new ClientUpgradeInfo
                    {
                        Name = Path.GetFileName(fileName),
                        Version = version,
                        Description = description,
                        IsDefault = true,
                    };
                    fileName = Path.Combine(CommonConfigManager.HandyToolClientFolder, clientInfo.Id.ToString());
                    FileUtils.ByteToFile(fileName, clientInfo.Name, clientData);
                    await HandyToolClientDataManager.CreateHandyToolClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} create HandyTool client info {version}.");
                    return;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Set the HandyTool client info to the default one.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="HandyToolClientInfoId">The HandyTool clientInfo id</param>
        /// <returns></returns>
        public async Task SetDefaultHandyToolClientAsync(long sessionId, long HandyToolClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var HandyToolClientDataManager = databaseService.GetManager<IHandyToolClientDataManager>();
                    var clientInfo = await HandyToolClientDataManager.GetHandyToolClientInfoAsync(HandyToolClientInfoId);
                    if (clientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    var defaultClientInfos = await HandyToolClientDataManager.GetDefaultHandyToolClientInfosAsync();
                    if (defaultClientInfos != null && defaultClientInfos.Count > 0)
                    {
                        await HandyToolClientDataManager.SetUndefaultHandyToolClientsAsync(defaultClientInfos.Select(x => x.Id).ToList());
                    }
                    clientInfo.IsDefault = true;
                    await HandyToolClientDataManager.UpdateHandyToolClientInfoAsync(clientInfo);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} set HandyTool client info {clientInfo.Version} to default.");
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the HandyTool client infos.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns>The found HandyTool client infos.</returns>
        public async Task<List<ClientUpgradeInfo>> GetHandyToolClientInfosAsync(long sessionId, int pageIndex, int pageSize, string keyword)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var HandyToolClientDataManager = databaseService.GetManager<IHandyToolClientDataManager>();
                    var result = await HandyToolClientDataManager.GetHandyToolClientInfosAsync(pageIndex, pageSize, keyword);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get page {pageIndex}, pageSize {pageSize} of HandyTool client infos from system.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Get all HandyTool client infos.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <returns>All HandyTool client infos.</returns>
        public async Task<int> GetHandyToolClientInfosCountAsync(long sessionId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var HandyToolClientDataManager = databaseService.GetManager<IHandyToolClientDataManager>();
                    var count = await HandyToolClientDataManager.GetHandyToolClientInfosCountAsync();
                    return (int)count;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        /// <summary>
        /// Delete the HandyTool client info.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="labelerClientInfoId">The HandyTool client info's id</param>
        /// <returns></returns>
        public async Task DeleteHandyToolClientInfoAsync(long sessionId, long HandyToolClientInfoId)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var HandyToolClientDataManager = databaseService.GetManager<IHandyToolClientDataManager>();
                    var HandyToolClientInfo = await HandyToolClientDataManager.GetHandyToolClientInfoAsync(HandyToolClientInfoId);
                    if (HandyToolClientInfo == null)
                    {
                        throw new InvalidOperationException("ClientInfoNotExist");
                    }
                    await HandyToolClientDataManager.DeleteHandyToolClientInfoAsync(HandyToolClientInfoId);
                    var HandyToolService = ServiceManager.GetService<IHandyToolService>() as HandyToolService;
                    HandyToolService?.RemoveClientData(HandyToolClientInfo.Version);

                    FileUtils.DeleteDirectory(Path.Combine(CommonConfigManager.HandyToolClientFolder, HandyToolClientInfoId.ToString()));
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} deleted HandyTool client info {HandyToolClientInfo.Version}.");

                    #region Set Default Client
                    if (HandyToolClientInfo.IsDefault)
                    {
                        var firstClientInfo = await HandyToolClientDataManager.GetLastHandyToolClientInfoAsync();
                        if (firstClientInfo != null && !firstClientInfo.IsDefault)
                        {
                            firstClientInfo.IsDefault = true;
                            await HandyToolClientDataManager.UpdateHandyToolClientInfoAsync(firstClientInfo);
                            await SystemLogger.WriteLogAsync($"Admin - {session.Name} set HandyTool client info {firstClientInfo.Version} to default.");
                        }
                    }
                    #endregion
                }
                else
                {
                    throw new InvalidOperationException("InvalidAdminSession");
                }
            }
            else
            {
                throw new InvalidOperationException("InvalidAdminSession");
            }
        }

        /// <summary>
        /// Get the HandyTool client info by version.
        /// </summary>
        /// <param name="sessionId">The id of the session.</param>
        /// <param name="version">The version of the HandyTool client info..</param>
        /// <returns>The reivewer client infos.</returns>
        public async Task<ClientUpgradeInfo> GetHandyToolClientInfoByVersionAsync(long sessionId, string version)
        {
            ActivateSession(sessionId);
            var session = SessionManager.GetSession(sessionId);
            if (session != null)
            {
                if (session.Type == SessionType.Admin)
                {
                    var databaseService = ServiceManager.GetService<IDatabaseService>();
                    var HandyToolClientDataManager = databaseService.GetManager<IHandyToolClientDataManager>();
                    var result = await HandyToolClientDataManager.GetHandyToolClientInfoAsync(version);
                    await SystemLogger.WriteLogAsync($"Admin - {session.Name} get HandyTool client info by version {version}.");
                    return result;
                }
            }
            throw new InvalidOperationException("InvalidAdminSession");
        }

        #endregion
    }
}