Exemple #1
0
        /// <summary>
        /// Set the user's password to the new password.
        /// </summary>
        /// <param name="user">The user to change.</param>
        /// <param name="oldPassword">The current password.</param>
        /// <param name="password">The new password.</param>
        private void ResetPassword(User user, string oldPassword, string password)
        {
            try
            {
                AdminSupportClient         adminSupportClient = new AdminSupportClient(Guardian.Properties.Settings.Default.AdminSupportEndpoint);
                AdminSupportReference.User userRecord         = new AdminSupportReference.User();
                MethodResponseErrorCode    response           = null;

                DataModel.IsReading = false;

                if (user.UserId == UserContext.Instance.UserId)
                {
                    response = adminSupportClient.ChangePassword(oldPassword, password);

                    if (response.IsSuccessful)
                    {
                        ChannelStatus.LoginEvent.Set();
                        ChannelStatus.IsPrompted = false;
                        ChannelStatus.Secret     = password;
                        ChannelStatus.LogggedInEvent.Set();
                    }
                }
                else
                {
                    response = adminSupportClient.ResetPassword(user.IdentityName, password);
                }

                if (!response.IsSuccessful)
                {
                    GuardianObject.ThrowErrorInfo(response.Errors[0]);
                }

                adminSupportClient.Close();
            }
            catch (FaultException <ArgumentFault> )
            {
                this.Dispatcher.BeginInvoke(new Action(() =>
                                                       MessageBox.Show(this, String.Format(Properties.Resources.ResetPasswordFailedPoorComplexity, user), this.Title)));
            }
            catch (SecurityAccessDeniedException)
            {
                this.Dispatcher.BeginInvoke(new Action(() =>
                                                       MessageBox.Show(this, String.Format(Properties.Resources.UserNotFound, user), this.Title)));
            }
            catch (FaultException <RecordNotFoundFault> )
            {
                this.Dispatcher.BeginInvoke(new Action(() =>
                                                       MessageBox.Show(this, String.Format(Properties.Resources.ResetPasswordFailedPermissionDenied, user), this.Title)));
            }
            catch (Exception exception)
            {
                // Any issues trying to communicate to the server are logged.
                EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace);
                this.Dispatcher.BeginInvoke(new Action(() =>
                                                       MessageBox.Show(this, String.Format(Properties.Resources.ResetPasswordFailed, user.Name), this.Title)));
            }
            finally
            {
                DataModel.IsReading = true;
            }
        }
Exemple #2
0
 /// <summary>
 /// Copies the data from one entity to another.
 /// </summary>
 /// <param name="entity">The source entity.</param>
 public override void Copy(GuardianObject entity)
 {
     base.Copy(entity);
     this.rowVersion = (entity as DebtHolder).RowVersion;
 }
Exemple #3
0
        /// <summary>
        /// Delete an set of debt holders.
        /// </summary>
        /// <param name="debtHolders">The set of working orders.</param>
        /// <returns>The actual bulk size used.</returns>
        protected override Int32 Delete(List <GuardianObject> debtHolders)
        {
            Int32          attemptedBulkSize = debtHolders.Count;
            Int32          actualBulkSize    = attemptedBulkSize;
            GuardianObject failedObject      = null;

            TradingSupportReference.DebtHolder[] records = new TradingSupportReference.DebtHolder[debtHolders.Count];
            Dictionary <TradingSupportReference.DebtHolder, DebtHolder> recordsToHolders =
                new Dictionary <TradingSupportReference.DebtHolder, DebtHolder>();

            // Convert the GuardianObjects to records we can push up to the server.
            for (Int32 index = 0; index < records.Length; ++index)
            {
                DebtHolder debtHolder = debtHolders[0] as DebtHolder;

                records[index] = new TradingSupportReference.DebtHolder();
                debtHolder.PopulateRecord(records[index]);
                recordsToHolders[records[index]] = debtHolder;
                debtHolders.RemoveAt(0);
            }

            try
            {
                Int32 sentSize;
                MethodResponseErrorCode response;

                response = NetworkHelper.Attempt <MethodResponseErrorCode>(
                    (client, a) =>
                    client.DeleteDebtHolder(a as TradingSupportReference.DebtHolder[]),
                    records,
                    true,
                    out sentSize);

                if (sentSize < attemptedBulkSize)
                {
                    actualBulkSize = sentSize;
                }

                if (!response.IsSuccessful)
                {
                    List <TradingSupportReference.DebtHolder> retryRecords = new List <TradingSupportReference.DebtHolder>();

                    foreach (ErrorInfo errorInfo in response.Errors)
                    {
                        // The bulk index is an index into the set we sent, which may be smaller than the set passed in.
                        failedObject = recordsToHolders[records[errorInfo.BulkIndex]];

                        // If the error's "just" a deadlock, we should retry it.
                        if (errorInfo.ErrorCode == ErrorCode.Deadlock)
                        {
                            retryRecords.Add(records[errorInfo.BulkIndex]);
                        }
                        else if (errorInfo.ErrorCode == ErrorCode.RecordExists)
                        {
                            throw new HasSettlementsException(this.ToString() + " has settled accounts");
                        }
                        // We can safely ignore not-found errors (we are deleting after all), but if the error's more severe, forget the how
                        // thing and throw up the error.
                        else if (errorInfo.ErrorCode != ErrorCode.RecordNotFound)
                        {
                            GuardianObject.ThrowErrorInfo(response.Errors[0]);
                        }
                    }

                    records = retryRecords.ToArray();
                }
            }
            catch (Exception exception)
            {
                // Any issues trying to communicate to the server are logged.
                EventLog.Error("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
                throw new DeleteException(failedObject, exception);
            }

            return(actualBulkSize);
        }
 /// <summary>
 /// Move this working order from one blotter to another.
 /// </summary>
 /// <param name="newParent">The new location of the working order.</param>
 /// <param name="errors">The list of errors and at what index.</param>
 public void Move(GuardianObject newParent, List <ErrorInfo> errors)
 {
     this.Move(new List <IMovableObject> {
         this
     }, newParent, errors);
 }
        /// <summary>
        /// Update this entity with contents of another one.
        /// </summary>
        /// <param name="entity">The entity to update from.</param>
        public override void Copy(GuardianObject entity)
        {
            base.Copy(entity);

            this.tenant = (entity as RightsHolder).Tenant;
        }
Exemple #6
0
 /// <summary>
 /// Copies the data from one entity to another.
 /// </summary>
 /// <param name="obj">The source entity.</param>
 public virtual void Copy(GuardianObject obj)
 {
     this.modified = obj.Modified;
 }
Exemple #7
0
 /// <summary>
 /// Update this object based on another.
 /// </summary>
 /// <param name="obj">The object to draw updates from.</param>
 public abstract void Update(GuardianObject obj);
Exemple #8
0
        /// <summary>
        /// Move the move list, updating the progress bar as we go.
        /// </summary>
        private void Move(GuardianObject target)
        {
            List <IMovableObject> objects = null;
            List <FluidTrade.Guardian.TradingSupportReference.ErrorInfo> errors = new List <FluidTrade.Guardian.TradingSupportReference.ErrorInfo>();

            try
            {
                // Run through the delete list in LIFO order, maintaining the integrity of the entity tree as we delete.
                while (this.moveList.Count > 0)
                {
                    objects = this.GetBatch();

                    this.Dispatcher.BeginInvoke(new WaitCallback(name =>
                                                                 this.Message = String.Format(FluidTrade.Guardian.Properties.Resources.MovingObject, name as String)),
                                                DispatcherPriority.Normal, objects[0].ToString());

                    if (objects.Count == 1)
                    {
                        objects[0].Move(target, errors);
                    }
                    else
                    {
                        objects[0].Move(objects, target, errors);
                    }

                    // The progress bar properties belong to the foreground, so toss the increment up to the main thread.
                    this.Dispatcher.BeginInvoke(new WaitCallback(
                                                    delegate(object count)
                    {
                        this.TimeLeftVisibility = Visibility.Visible;
                        this.Value   += (Int32)count;
                        TimeSpan left = new TimeSpan((long)((this.Maximum - this.Value) * ((DateTime.Now - this.startTime).Ticks / this.Value)));
                        this.TimeLeft = left < TimeSpan.Zero ? TimeSpan.Zero : left;
                    }),
                                                DispatcherPriority.Normal, objects.Count);
                }
            }
            catch (SecurityAccessDeniedException exception)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                String.Format(FluidTrade.Guardian.Properties.Resources.MoveFailedAccessDenied, data),
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal,
                                                           objects[0]);

                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }
            catch (Exception exception)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                String.Format(FluidTrade.Guardian.Properties.Resources.MoveFailed, data),
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal,
                                                           objects[0]);

                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }

            if (errors.Count > 0)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                FluidTrade.Guardian.Properties.Resources.MovePartialFail,
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal,
                                                           objects[0]);
            }

            // We're done. Windows Explorer doesn't throw up an alert, so we won't either.
            this.Dispatcher.BeginInvoke(new Action(this.Close), DispatcherPriority.Normal);
        }
        /// <summary>
        /// Delete the delete list, updating the progress bar as we go.
        /// </summary>
        private void Delete()
        {
            List <GuardianObject> objects      = null;
            GuardianObject        failedObject = null;

            try
            {
                try
                {
                    // Run through the delete list in LIFO order, maintaining the integrity of the entity tree as we delete.
                    while (this.deleteList.Count > 0)
                    {
                        objects = this.GetBatch();

                        this.Dispatcher.BeginInvoke(new WaitCallback(name =>
                                                                     this.Message = String.Format(FluidTrade.Guardian.Properties.Resources.DeletingObject, name as String)),
                                                    DispatcherPriority.Normal, objects[0].ToString());

                        if (objects.Count == 1)
                        {
                            objects[0].Commit();
                        }
                        else
                        {
                            Int32 attemptedSize = objects.Count;
                            Int32 sentSize      = objects[0].Commit(objects);

                            if (sentSize < attemptedSize)
                            {
                                this.batchSize = sentSize;
                            }
                        }

                        // The progress bar properties belong to the foreground, so toss the increment up to the main thread.
                        this.Dispatcher.BeginInvoke(new WaitCallback(delegate(object count)
                        {
                            this.TimeLeftVisibility = Visibility.Visible;
                            this.Value   += (Int32)count;
                            TimeSpan left = new TimeSpan((long)((this.Maximum - this.Value) * ((DateTime.Now - this.startTime).Ticks / this.Value)));
                            this.TimeLeft = left < TimeSpan.Zero ? TimeSpan.Zero : left;
                        }),
                                                    DispatcherPriority.Normal, objects.Count);
                    }
                }
                catch (DeleteException capturedException)
                {
                    failedObject = capturedException.FailedObject;
                    throw capturedException.InnerException;
                }
            }
            catch (IsSettledException exception)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                String.Format(FluidTrade.Guardian.Properties.Resources.DeleteFailedIsSettledAccount, data),
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal,
                                                           failedObject);

                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }
            catch (HasSettlementsException exception)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                String.Format(FluidTrade.Guardian.Properties.Resources.DeleteFailedHasSettledAccounts, data),
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal,
                                                           failedObject);

                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }
            catch (SecurityAccessDeniedException exception)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                String.Format(FluidTrade.Guardian.Properties.Resources.DeleteFailedAccessDenied, data),
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal,
                                                           failedObject);

                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }
            catch (CommunicationObjectFaultedException exception)
            {
                Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                            MessageBox.Show(
                                                                                Application.Current.MainWindow,
                                                                                String.Format(FluidTrade.Guardian.Properties.Resources.DeleteFailedConnectionDropped),
                                                                                Application.Current.MainWindow.Title)),
                                                           DispatcherPriority.Normal);

                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }
            catch (Exception exception)
            {
                if (failedObject != null)
                {
                    Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                                MessageBox.Show(
                                                                                    Application.Current.MainWindow,
                                                                                    String.Format(FluidTrade.Guardian.Properties.Resources.DeleteFailed, data),
                                                                                    Application.Current.MainWindow.Title)),
                                                               DispatcherPriority.Normal,
                                                               failedObject);
                }
                else
                {
                    Application.Current.Dispatcher.BeginInvoke(new WaitCallback(data =>
                                                                                MessageBox.Show(
                                                                                    Application.Current.MainWindow,
                                                                                    String.Format(FluidTrade.Guardian.Properties.Resources.DeleteFailedCompletely),
                                                                                    Application.Current.MainWindow.Title)),
                                                               DispatcherPriority.Normal);
                }


                EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
            }

            // We're done. Windows Explorer doesn't throw up an alert, so we won't either.
            this.Dispatcher.BeginInvoke(new Action(this.Close), DispatcherPriority.Normal);
        }
Exemple #10
0
        /// <summary>
        /// Commit any changes to this user to the server.
        /// </summary>
        public override void Commit()
        {
            AdminSupportClient client = new AdminSupportClient(Guardian.Properties.Settings.Default.AdminSupportEndpoint);

            AdminSupportReference.User user = new AdminSupportReference.User();
            MethodResponseErrorCode    response;

            this.PopulateRecord(user);

            if (this.Deleted)
            {
                response = client.DeleteUserAccount(user.LookupId);

                if (this.GetFirstErrorCode(response) == ErrorCode.RecordNotFound)
                {
                    throw new UserNotFoundException(this, "User not found");
                }
            }
            else
            {
                response = client.UpdateUser(new AdminSupportReference.User[] { user });

                if (this.GetFirstErrorCode(response) == ErrorCode.RecordNotFound)
                {
                    throw new UserNotFoundException(this, "User not found");
                }

                if (response.IsSuccessful)
                {
                    if (this.AccountDisabled)
                    {
                        response = client.DisableUserAccount(this.IdentityName);
                    }
                }

                if (response.IsSuccessful)
                {
                    lock (DataModel.SyncRoot)
                    {
                        List <Group>    newGroups = this.Groups.ToList();
                        List <Guid>     add       = new List <Guid>();
                        List <Guid>     del       = new List <Guid>();
                        GroupUsersRow[] oldGroups = DataModel.User.UserKey.Find(this.UserId).GetGroupUsersRows();
                        ErrorCode       firstError;

                        foreach (GroupUsersRow groupUsersRow in oldGroups)
                        {
                            Group group = newGroups.FirstOrDefault(g => g.GroupId == groupUsersRow.GroupId);

                            if (group == null)
                            {
                                del.Add(groupUsersRow.GroupId);
                            }
                            else
                            {
                                if (group.Deleted)
                                {
                                    del.Add(group.GroupId);
                                }
                                newGroups.Remove(group);
                            }
                        }

                        foreach (Group group in newGroups)
                        {
                            response = client.AddUserToGroup(this.IdentityName, group.GroupId, this.TenantId);

                            firstError = this.GetFirstErrorCode(response);

                            if (firstError == ErrorCode.RecordNotFound)
                            {
                                throw new GroupNotFoundException(this.DefaultGroup, "Group not found");
                            }
                            else if (firstError != ErrorCode.Success)
                            {
                                break;
                            }
                        }

                        foreach (Guid group in del)
                        {
                            response = client.RemoveUserFromGroup(this.IdentityName, group);

                            firstError = this.GetFirstErrorCode(response);

                            if (firstError != ErrorCode.RecordNotFound && firstError != ErrorCode.Success)
                            {
                                break;
                            }
                        }
                    }
                }
            }

            if (!response.IsSuccessful)
            {
                GuardianObject.ThrowErrorInfo(response.Errors[0]);
            }

            client.Close();

            this.Modified = false;
        }