private void SetConnection(ConnectionInfo connectionInfo)
        {
            using (var db = new LicensingEntities())
            {
                Guid ConnectionID = Guid.Parse(connectionInfo.ConnectionId);

                var users = db.User.Where(f => f.UserName == connectionInfo.UserName);

                if (users.Count() == 0)
                {
                    int Isrole;

                    if (!int.TryParse(connectionInfo.Role, out Isrole))
                    {
                        Isrole = 1;
                    }

                    var user = new User
                    {
                        ID = Guid.NewGuid(),
                        UserName = connectionInfo.UserName,
                        Company = connectionInfo.Company,
                        ProjectType = connectionInfo.ProjectType,
                        Role = Isrole,
                        LastActivity = connectionInfo.CurrentDateTime
                    };

                    db.User.Add(user);
                }
                else
                {
                    var user = users.First();
                    user.LastActivity = DateTime.UtcNow;
                }

                var _connections = db.Connection.Where(con => con.ConnectionID == ConnectionID);

                if (_connections.Count() == 0)
                {
                    CreateConnection(connectionInfo);
                }

                var _waitConnection = db.WaitConnection.Where(waitCon => waitCon.ConnectionID == ConnectionID);

                if(_waitConnection.Count() > 0)
                {
                    var waitConnectionItem = _waitConnection.First();
                    waitConnectionItem.IsLicense = true;
                }

                db.SaveChanges();
            }
        }
        public void OnConnected(ConnectionInfo connectionInfo)
        {
            lock (_entryObject)
            {
                logWrite(connectionInfo.ConnectionId, "OnConnected Start");

                if (connectionInfo.Role == ((int)Role.user).ToString())
                {
                    connectionInfo.CurrentDateTime = DateTime.UtcNow;

                    using (var db = new LicensingEntities())
                    {
                        //라이센스 이름을 구별
                        var myLicenses = db.Connection.Where(
                            li => li.ConnectedDateTime <= connectionInfo.CurrentDateTime &&
                                  li.DisConnectedDateTime.HasValue == false &&
                                  li.StopCalled.HasValue == false &&
                                  li.Company.ToLower() == connectionInfo.Company.ToLower() &&
                                  li.ProjectType.ToLower() == connectionInfo.ProjectType.ToLower() &&
                                  li.UserName.ToLower() == connectionInfo.UserName.ToLower()).ToList();
                        
                        if (myLicenses.Count >= 1)
                        {
                            var myLicense = myLicenses.First();

                            joinLicense(connectionInfo.ConnectionId);

                            SetConnection(connectionInfo);
                        }
                        else
                        {
                            GetLicense(connectionInfo);
                        }

                        Clients.Group(((int)Role.manager).ToString()).NewConnection(connectionInfo);
                    }
                }

                logWrite(connectionInfo.ConnectionId, "OnConnected End");
            }
        }
        //라이센스 획득 구문
        private void GetLicense(ConnectionInfo connectionInfo)
        {
            using (var db = new LicensingEntities())
            {
                var licenseCompanys = db.LicenseCompany.Where(LC =>
                                            LC.Company.ToLower() == connectionInfo.Company.ToLower() &&
                                            LC.ProjectType.ToLower() == connectionInfo.ProjectType.ToLower());

                if (licenseCompanys.Count() > 0)
                {
                    var Companys = licenseCompanys.First();

                    //현재 라이센스 유저 수를 가져와서
                    var licenseUsers = db.Connection.Where(li => li.ConnectedDateTime <= connectionInfo.CurrentDateTime &&
                             li.DisConnectedDateTime.HasValue == false &&
                             li.StopCalled.HasValue == false &&
                             li.Company.ToLower() == connectionInfo.Company.ToLower() &&
                             li.ProjectType.ToLower() == connectionInfo.ProjectType.ToLower()).ToList();

                    IEnumerable<Connection> licenseCount =licenseUsers.Distinct(new ConnectionComparer());
                    int currentLicense = licenseCount.Count();

                    //라이센스 업데이트 구문
                    if (Companys.LicenseMaxium > currentLicense)
                    {
                        logWrite(connectionInfo.ConnectionId, "현재 라이센스 개수" + currentLicense.ToString());

                        joinLicense(connectionInfo.ConnectionId);

                        SetConnection(connectionInfo);
                    }
                    else
                    {
                        var connectionId = Guid.Parse(connectionInfo.ConnectionId);

                        var WaitConnection = db.WaitConnection.Where(waitItem => waitItem.ConnectionID == connectionId);

                        if(WaitConnection.Count() > 0)
                        {
                            var waitConnectionItem = WaitConnection.First();
                            waitConnectionItem.LastActivity = connectionInfo.CurrentDateTime;
                            db.SaveChanges();
                        }
                        else
                        {
                            CreateWaitConnection(connectionInfo);
                        }
                      
                        //라이센스가 꽉찼을 경우 대기를 해야한다.
                        if (Companys.LicenseMaxium == 0)
                        {
                            fullLicense(connectionInfo.ConnectionId, "License 적용되지않았습니다.");
                        }
                        else
                        {
                            fullLicense(connectionInfo.ConnectionId, "현재 라이센스가 꽉 찼습니다.");
                        }
                    }
                }
                else
                {
                    logWrite(connectionInfo.ConnectionId, "라이센스 정보가 없습니다.");
                }
            }
        
        }
 private void CreateWaitConnection(ConnectionInfo connectionInfo)
 {
     using (var db = new LicensingEntities())
     {
         db.WaitConnection.Add(new WaitConnection()
         {
             ConnectionID = Guid.Parse(connectionInfo.ConnectionId),
             UserAgent = (connectionInfo.UserAgent != null ? connectionInfo.UserAgent : string.Empty),
             Company = connectionInfo.Company,
             ProjectType = connectionInfo.ProjectType,
             IsLicense = false,
             ConnectedDateTime = connectionInfo.CurrentDateTime,
             Transport = connectionInfo.Transport,
             LastActivity = connectionInfo.CurrentDateTime,
             UserName = connectionInfo.UserName,
             ExtensionV1 = connectionInfo.ExtensionV1,
             ExtensionV2 = connectionInfo.ExtensionV2,
             Status = connectionInfo.Status
         });
         db.SaveChanges();
     }
 }
        private void CreateConnection(ConnectionInfo connectionInfo)
        {
            logWrite(connectionInfo.ConnectionId, "Connection 생성 중입니다.");

            using (var db = new LicensingEntities())
            {
                var _connection = new Connection
                {
                    ConnectionID = Guid.Parse(connectionInfo.ConnectionId),
                    UserAgent = (connectionInfo.UserAgent != null ? connectionInfo.UserAgent : string.Empty),
                    Company = connectionInfo.Company,
                    ProjectType = connectionInfo.ProjectType,
                    ConnectedDateTime = connectionInfo.CurrentDateTime,
                    Transport = connectionInfo.Transport,
                    LastActivity = connectionInfo.CurrentDateTime,
                    UserName = connectionInfo.UserName,
                    ExtensionV1 = connectionInfo.ExtensionV1,
                    ExtensionV2 = connectionInfo.ExtensionV2,
                    Status = connectionInfo.Status
                };

                db.Connection.Add(_connection);
                db.SaveChanges();

            }
        }
        private void SetReConnection(ConnectionInfo reConnectionInfo)
        {
            Guid ConnectionID = Guid.Parse(reConnectionInfo.ConnectionId);

            using (var db = new LicensingEntities())
            {
                var users = db.User.Where(f => f.UserName == reConnectionInfo.UserName);

                if (users.Count() > 0)
                {
                    var user = users.First();
                    user.LastActivity = reConnectionInfo.CurrentDateTime;
                }
                else
                {
                    var user = new User
                    {
                        ID = Guid.NewGuid(),
                        UserName = reConnectionInfo.UserName,
                        Company = reConnectionInfo.Company,
                        ProjectType = reConnectionInfo.ProjectType,
                        Role = 1,
                        LastActivity = reConnectionInfo.CurrentDateTime
                    };

                    db.User.Add(user);
                }

                var _connections = db.Connection.Where(con => con.ConnectionID == ConnectionID);

                if (_connections.Count() > 0)
                {
                    var _connection = _connections.First();
                    _connection.ReConnectedDateTime = reConnectionInfo.CurrentDateTime;
                    _connection.LastActivity = reConnectionInfo.CurrentDateTime;
                    _connection.Status = (int)ConnectionStatus.OnReConnected;
                }
                else
                {
                    CreateConnection(reConnectionInfo);
                }

                var _waitConnection = db.WaitConnection.Where(waitCon => waitCon.ConnectionID == ConnectionID);

                if (_waitConnection.Count() > 0)
                {
                    var waitConnectionItem = _waitConnection.First();
                    waitConnectionItem.ReConnectedDateTime = reConnectionInfo.CurrentDateTime;
                    waitConnectionItem.LastActivity = reConnectionInfo.CurrentDateTime;
                    waitConnectionItem.Status = (int)ConnectionStatus.OnReConnected;
                    waitConnectionItem.IsLicense = true;
                }

                db.SaveChanges();

            }
        }
コード例 #7
0
        public void tryConnection()
        {
            ConnectionInfo connectionInfo = new ConnectionInfo()
            {
                Company = Company,
                UserName = UserName,
                ConnectionId = Context.ConnectionId,
                ExtensionV1 = ExtensionV1,
                ExtensionV2 = ExtensionV2,
                ProjectType = ProjectType,
                CurrentDateTime = DateTime.UtcNow,
                Status = (int)ConnectionStatus.OnReConnected,
                Transport = Transport,
                UserAgent = UserAgent,
                Role = UserRole
            };

            connectionContext.tryConnection(connectionInfo);

            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
コード例 #8
0
        public override System.Threading.Tasks.Task OnReconnected()
        {
            Groups.Add(Context.ConnectionId, UserRole);

            ConnectionInfo reConnection = new ConnectionInfo()
            {
                Company = Company,
                UserName = UserName,
                ConnectionId = Context.ConnectionId,
                ExtensionV1 = ExtensionV1,
                ExtensionV2 = ExtensionV2,
                ProjectType = ProjectType,
                Status = (int)ConnectionStatus.OnReConnected,
                Transport = Transport,
                UserAgent = UserAgent,
                Role = UserRole
            };

            connectionContext.OnReConnected(reConnection);
            GC.Collect();
            GC.WaitForPendingFinalizers();

            return base.OnReconnected();

        }