Beispiel #1
0
        void OnUpdateServerSettings(object sender, EventArgs e)
        {
            if (_view != null)
            {
                IAeManagementDataAccessAgent         agent            = DataAccessServices.GetDataAccessService <IAeManagementDataAccessAgent>();
                IPermissionManagementDataAccessAgent permissionsAgent = DataAccessServices.GetDataAccessService <IPermissionManagementDataAccessAgent>();

#if LEADTOOLS_V20_OR_LATER
                IOptionsDataAccessAgent optionsAgent = DataAccessServices.GetDataAccessService <IOptionsDataAccessAgent>();

                if (optionsAgent != null)
                {
                    ClientConfigurationOptions clientConfigurationOptions = optionsAgent.Get <ClientConfigurationOptions>(ClientConfigurationOptionsKeyName, new ClientConfigurationOptions());
                    if (clientConfigurationOptions != null)
                    {
                        View.Options = clientConfigurationOptions;
                    }
                }
#endif // #if LEADTOOLS_V20_OR_LATER

                AeInfoExtended[] aeInfoExtendedArray = agent.GetAeTitles();
                List <string>    aeTitlesInDB        = new List <string>();

                foreach (AeInfoExtended ae in aeInfoExtendedArray)
                {
                    ClientInformation info = (from i in ServerState.Instance.ClientList.Items
                                              where i.Client.AETitle == ae.AETitle
                                              select i).FirstOrDefault();

                    //
                    // Only add items that existed when the database was first queried. If an ae title was added outside of this dialog
                    //  it will be ignored.
                    //
                    if (info != null)
                    {
                        aeTitlesInDB.Add(ae.AETitle.ToUpper());
                    }
                }

                // Updates and adds
                foreach (ClientInformation ci in _view.ClientInformationList.Items)
                {
                    string aeTitle = ci.Client.AETitle;
                    if (aeTitlesInDB.Contains(aeTitle, StringComparer.InvariantCultureIgnoreCase))
                    {
                        // update
                        ClientInformation ciPrevious = null;
                        ServerState.Instance.ClientList.ClientDictionary.TryGetValue(aeTitle, out ciPrevious);

                        if (!ciPrevious.Equals(ci))
                        {
                            agent.Update(aeTitle, ci.Client);
                        }
                        aeTitlesInDB.Remove(aeTitle.ToUpper());
                        try
                        {
                            EventBroker.Instance.PublishEvent <ClientUpdatedEventArgs>(this, new ClientUpdatedEventArgs(aeTitle, ci.Client));
                        }
                        catch { }
                    }
                    else
                    {
                        // insert
                        agent.Add(ci.Client);
                        try
                        {
                            EventBroker.Instance.PublishEvent <ClientAddedEventArgs>(this, new ClientAddedEventArgs(ci.Client));
                        }
                        catch { }
                    }
                    permissionsAgent.DeleteUserPermission(null, aeTitle);
                    foreach (string permissionName in ci.Permissions)
                    {
                        permissionsAgent.AddUserPermission(permissionName, aeTitle);
                    }
                }

                // Finally, remove the deleted AE titles from the database
                foreach (string aeTitle in aeTitlesInDB)
                {
                    agent.Remove(aeTitle);
                    try
                    {
                        EventBroker.Instance.PublishEvent <ClientRemovedEventArgs>(this, new ClientRemovedEventArgs(aeTitle));
                    }
                    catch { }
                }

                ServerState.Instance.ClientList = new ClientInformationList(_view.ClientInformationList);
            }
        }
Beispiel #2
0
        public static void UpdateUsers(UsersSource users)
        {
            UsersSource     usersDataSet;
            PasswordOptions options = optionsAgent.Get <PasswordOptions>(PasswordOptionsPresenter.PasswordOptions, new PasswordOptions());

            User[] currentUsers = userAgent.GetUsers();

            // int xxx = 100;
            // if (xxx != 100)
            // {
            //   users.Dispose();
            //   GC.Collect();
            //   GC.WaitForPendingFinalizers();
            // }

            bool forceDeleteAllUsers = IsForceDeleteAllUsers();

            if (forceDeleteAllUsers)
            {
                var rowsToDelete = new List <DataRow>();
                foreach (DataRow row in users.Users.Rows)
                {
                    rowsToDelete.Add(row);
                }

                foreach (DataRow row in rowsToDelete)
                {
                    // users.Users.Rows.Remove(row);
                    row.Delete();
                }
            }

            usersDataSet = (UsersSource)users.GetChanges();

            if (null == usersDataSet)
            {
                return;
            }

            if (IsDeleteAllUsers(currentUsers, usersDataSet))
            {
                users.RejectChanges();
                Shell.LogAudit(string.Format("Rejected: Delete All Users"));
                // System.Windows.Forms.MessageBox.Show("Rejected: Delete All Users");
                return;
            }

            int i = 0;

            foreach (UsersSource.UsersRow user in usersDataSet.Users)
            {
                if (user.RowState == DataRowState.Added)
                {
                    DateTime?expires = null;

                    if (user.IsNewPasswordNull())
                    {
                        throw new InvalidOperationException("New user has no password.");
                    }
                    if (!user.IsExpiresNull())
                    {
                        expires = user.Expires;
                    }
#if LEADTOOLS_V19_OR_LATER
                    //userAgent.AddUser(user.UserName, user.FriendlyName, user.NewPassword, expires, user.UseCardReader);
                    userAgent.AddUser(user.UserName, user.FriendlyName, user.NewPassword, expires, user.UseCardReader?"smartcard":"classic");
#else
                    userAgent.AddUser(user.UserName, user.NewPassword, expires);
#endif

                    Shell.LogAudit(string.Format(AuditMessages.NewUserAdded.Message, user.GetDisplayName()));
                }
                else if (user.RowState == DataRowState.Deleted)
                {
                    string username        = Convert.ToString(usersDataSet.Users.Rows[i][0, DataRowVersion.Original]);
                    string displayNameTemp = Convert.ToString(usersDataSet.Users.Rows[i][5, DataRowVersion.Original]);

                    string displayName = username;
                    if (!string.IsNullOrEmpty(displayNameTemp))
                    {
                        displayName = displayNameTemp;
                    }

                    userAgent.RemoveUser(username);

                    Shell.LogAudit(string.Format(AuditMessages.UserRemoved.Message, displayName));
                }
                else if (user.RowState == DataRowState.Modified)
                {
                    if (!user.IsNewPasswordNull())
                    {
                        DateTime?expires = null;

                        if (!user.IsExpiresNull())
                        {
                            expires = user.Expires;
                        }

                        userAgent.SetUserPassword(user.UserName, user.NewPassword, expires, options.MaxPasswordHistory);

                        Shell.LogAudit(string.Format(AuditMessages.UserPasswordChanged.Message, user.GetDisplayName()));
                    }
                }
                i++;
            }

            i = 0;
            bool currentUserPermissionChanged = false;

            foreach (UsersSource.UserPermissionsRow permission in usersDataSet.UserPermissions)
            {
                string username = string.Empty;
                if (permission.RowState == DataRowState.Added)
                {
                    username = permission.UserName;
                }
                else if (permission.RowState == DataRowState.Deleted)
                {
                    username = Convert.ToString(usersDataSet.UserPermissions.Rows[i][0, DataRowVersion.Original]);
                }

                Leadtools.Medical.UserManagementDataAccessLayer.User existingUser =
                    currentUsers.SingleOrDefault(x => x.UserName == username);

                UsersSource.UsersRow addedUserRow = usersDataSet.Users.SingleOrDefault(x => x.UserName == username);

                string displayName = username;

#if LEADTOOLS_V19_OR_LATER
                if (existingUser != null)
                {
                    displayName = existingUser.GetDisplayName();
                }
                else if (addedUserRow != null)
                {
                    displayName = addedUserRow.GetDisplayName();
                }
#endif

                if (permission.RowState == DataRowState.Added)
                {
                    permissionsAgent.AddUserPermission(permission.Permission, permission.UserName);

                    Shell.LogAudit(string.Format(AuditMessages.PermissionAdded.Message, displayName, permission.Permission));

                    if (permission.UserName == User.Name)
                    {
                        currentUserPermissionChanged = true;

                        User.Permissions.Add(permission.Permission);
                    }
                }
                else if (permission.RowState == DataRowState.Deleted)
                {
                    string p = Convert.ToString(usersDataSet.UserPermissions.Rows[i][1, DataRowVersion.Original]);

                    permissionsAgent.DeleteUserPermission(p, username);

                    Shell.LogAudit(string.Format(AuditMessages.PermissionRemoved.Message, displayName, p));

                    if (username == User.Name)
                    {
                        currentUserPermissionChanged = true;

                        User.Permissions.Remove(p);
                    }

                    i++;
                }
            }

            users.AcceptChanges( );

            if (currentUserPermissionChanged)
            {
                EventBroker.Instance.PublishEvent <CurrentUserPemissionsChangedEventArgs> (null, new CurrentUserPemissionsChangedEventArgs( ));
            }
        }