TaskReconcile TaskCompletionButtons

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using DevExpress.XtraBars;
using DevExpress.XtraBars.Docking2010;
using DevExpress.XtraBars.Ribbon;
using DocsVision.BackOffice.CardLib.CardDefs;
using DocsVision.BackOffice.ObjectModel;
using DocsVision.BackOffice.ObjectModel.Services.Entities.KindSetting;
using DocsVision.Platform.Data.Metadata;
using DocsVision.Platform.Data.Metadata.CardModel;

namespace DigDes.AnteiManagement.Helpers
{
    public partial class TaskReconcile
    {
        private string completeTaskByCompletionParameterLogMessage;
        internal IMetadataProvider MetadataProvider
        {
            get { return MyContext.GetService<IMetadataProvider>(); }
        }

        private RibbonPage commonRibbonPage;

        internal RibbonPage CommonRibbonPage
        {
            get
            {
                return commonRibbonPage ?? (commonRibbonPage = Customizable.RibbonControl.Pages[0]);
            }
        }

        private TaskCompletionParameter currentCompletionParameter;

        internal string CompleteTaskByCompletionParameterLogMessage;

        private RibbonPageGroup ribbonCompletionParameterPageGroup;

        //internal RibbonPageGroup RibbonCompletionParameterPageGroup
        //{
        //    get
        //    {
        //        return ribbonCompletionParameterPageGroup ??
        //               (ribbonCompletionParameterPageGroup = ControlsDictionary.FindRibbonPageGroup("pseudoCompletion"));
        //    }
        //}

        private TaskSetting _taskSetting;

        internal TaskSetting TaskSetting
        {
            get
            {
                return _taskSetting ??
                       (_taskSetting =
                           Task != null ? TaskService.GetKindSettings(Task.SystemInfo.CardKind) : null);
            }
        }
        private void UpdateRibbonCompletionParameters()
        {
            if (this.Task.SystemInfo.State == null)
            {
                if (this.commonRibbonPage.Groups.Contains(ribbonCompletionParameterPageGroup))
                {
                    this.commonRibbonPage.Groups.Remove(ribbonCompletionParameterPageGroup);
                }
                return;
            }
            System.Collections.Generic.IEnumerable<StatesStateMachineBranch> source = StateService.FindLineBranchesByStartState(this.Task.SystemInfo.State);
            if (source.FirstOrDefault((StatesStateMachineBranch item) => item.EndState.BuiltInState == Task.CompletedState.Id && item.Operation.BuiltInOperation == Task.CompleteOperation.Id) == null)
            {
                if (this.commonRibbonPage.Groups.Contains(ribbonCompletionParameterPageGroup))
                {
                    this.commonRibbonPage.Groups.Remove(ribbonCompletionParameterPageGroup);
                }
                return;
            }
            System.Collections.Generic.List<TaskCompletionParameter> list = this.TaskService.GetCompletionParameters(this.Task).ToList<TaskCompletionParameter>();
            if (list.Count == 1 && list[0].Name.Equals(this.TaskSetting.Name))
            {
                this.UpdateRibbonCompletionParameter(list[0]);
                return;
            }
            BarButtonItem[] array;
            this.UpdateRibbonCompletionParameters(list, out array);
            if (array != null && array.Length > 0)
            {
                if (!this.commonRibbonPage.Groups.Contains(ribbonCompletionParameterPageGroup))
                {
                    this.ribbonCompletionParameterPageGroup = new RibbonPageGroup("Варианты завершения")
                    {
                        Name = "pseudoCompletion",
                        AllowTextClipping = false,
                        ShowCaptionButton = false
                    };
                    this.commonRibbonPage.Groups.Add(this.ribbonCompletionParameterPageGroup);
                }
                this.ribbonCompletionParameterPageGroup.ItemLinks.Clear();
                BarButtonItem[] array2 = array;
                for (int i = 0; i < array2.Length; i++)
                {
                    BarButtonItem item2 = array2[i];
                    this.ribbonCompletionParameterPageGroup.ItemLinks.Add(item2);
                }
                return;
            }
            if (commonRibbonPage.Groups.Contains(ribbonCompletionParameterPageGroup))
            {
                commonRibbonPage.Groups.Remove(ribbonCompletionParameterPageGroup);
            }
        }

        private void UpdateRibbonCompletionParameters(System.Collections.Generic.IEnumerable<TaskCompletionParameter> completionParameters, out BarButtonItem[] buttons)
        {
            System.Collections.Generic.List<BarButtonItem> list = new System.Collections.Generic.List<BarButtonItem>();
            foreach (TaskCompletionParameter current in completionParameters)
            {
                BarButtonItem barButtonItem = new BarButtonItem(Customizable.BarManager, current.Name);
                barButtonItem.LargeGlyph = (barButtonItem.Glyph = this.GetCompletionParameterIcon(current));
                barButtonItem.Tag = current;
                if (current.Operation != null)
                {
                    barButtonItem.Visibility = (StateService.IsOperationAllowed(current.Operation, this.Task) ? BarItemVisibility.Always : BarItemVisibility.Never);
                    barButtonItem.Enabled = AccessCheckingService.IsOperationAllowed(this.Task, current.Operation);
                }
                barButtonItem.ItemClick += new ItemClickEventHandler(this.CompletionParameterItem_ItemClick);
                list.Add(barButtonItem);
            }
            buttons = list.ToArray();
        }

        private void UpdateRibbonCompletionParameter(TaskCompletionParameter taskCompletionParameter)
        {
            if (this.TaskSetting != null)
            {
                this.currentCompletionParameter = taskCompletionParameter;
                TaskCompletionParametersSetting taskCompletionParametersSetting = this.TaskSetting.Completion.TaskCompletionParametersSetting;
                SectionField field = this.MetadataProvider.GetField(taskCompletionParametersSetting.DisplayFieldId);
                if (Task.SystemInfo.State == null || taskCompletionParametersSetting.DisplayFieldSectionId == Guid.Empty || taskCompletionParametersSetting.DisplayFieldId == System.Guid.Empty || (taskCompletionParametersSetting.DisplayFieldType != DocsVision.Platform.Data.Metadata.CardModel.FieldType.Enum && field.LinkedSectionId != RefBaseUniversal.ItemTypes.ID))
                {
                    return;
                }
                IEnumerable<StatesStateMachineBranch> enumerable = StateService.FindLineBranchesByStartState(Task.SystemInfo.State);
                if (enumerable == null || enumerable.Count<StatesStateMachineBranch>() == 0 || this.commonRibbonPage.Groups.Contains(ribbonCompletionParameterPageGroup))
                {
                    this.commonRibbonPage.Groups.Remove(this.ribbonCompletionParameterPageGroup);
                    return;
                }
                if (enumerable.FirstOrDefault((StatesStateMachineBranch item) => item.EndState.BuiltInState == Task.CompletedState.Id && item.Operation.BuiltInOperation == Task.CompleteOperation.Id) != null && !this.commonRibbonPage.Groups.Contains(this.ribbonCompletionParameterPageGroup))
                {
                    this.ribbonCompletionParameterPageGroup = new RibbonPageGroup("Варианты завершения")
                    {
                        Name = "pseudoCompletion",
                        ShowCaptionButton = false,
                        AllowTextClipping = false
                    };
                    System.Collections.Generic.IEnumerable<BarButtonItem> enumerable2 = this.PrepareCompletionParameterButtons(field);
                    if (this.TaskSetting.Completion.TaskCompletionParametersSetting.DisplayType == CompletionParameterDisplayType.DropDown || enumerable2.Count<BarButtonItem>() > 3)
                    {
                        BarButtonItem barButtonItem = new BarButtonItem();
                        barButtonItem.ButtonStyle = BarButtonStyle.DropDown;
                        barButtonItem.Caption = "Выбрать решение";// Resources.TaskCardControl_ChangeCompletionParameterCaption;}
                        barButtonItem.DropDownControl = this.CreateCompletionParameterPopupMenu(enumerable2);
                        this.ribbonCompletionParameterPageGroup.ItemLinks.Add(barButtonItem);
                    }
                    else
                    {
                        if (this.TaskSetting.Completion.TaskCompletionParametersSetting.DisplayType == CompletionParameterDisplayType.Buttons)
                        {
                            foreach (BarButtonItem current in enumerable2)
                            {
                                this.ribbonCompletionParameterPageGroup.ItemLinks.Add(current);
                            }
                        }
                    }
                    this.commonRibbonPage.Groups.Add(this.ribbonCompletionParameterPageGroup);
                }
            }
        }

        private System.Collections.Generic.IEnumerable<BarButtonItem> PrepareCompletionParameterButtons(SectionField sectionField)
        {
            System.Collections.Generic.List<BarButtonItem> list = new System.Collections.Generic.List<BarButtonItem>();
            if (this.TaskSetting.Completion.TaskCompletionParametersSetting.DisplayFieldType == DocsVision.Platform.Data.Metadata.CardModel.FieldType.Enum)
            {
                using (System.Collections.Generic.IEnumerator<FieldEnumValue> enumerator = sectionField.EnumValues.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        FieldEnumValue current = enumerator.Current;
                        string localization = current.DisplayName.GetLocalization(System.Globalization.CultureInfo.CurrentCulture);
                        BarButtonItem barButtonItem = new BarButtonItem(Customizable.BarManager,
                            string.IsNullOrEmpty(localization) ? current.Name : localization) {Tag = current};
                        barButtonItem.ItemClick += new ItemClickEventHandler(this.CompletionParameterButton_ItemClick);
                        list.Add(barButtonItem);
                    }
                    return list;
                }
            }
            if (this.TaskSetting.Completion.TaskCompletionParametersSetting.DisplayFieldType == DocsVision.Platform.Data.Metadata.CardModel.FieldType.RefId && sectionField.LinkedSectionId == RefBaseUniversal.ItemTypes.ID)
            {
                BaseUniversalItemType @object = MyContext.GetObject<BaseUniversalItemType>(this.TaskSetting.Completion.TaskCompletionParametersSetting.ItemTypeId);
                if (@object != null)
                {
                    foreach (BaseUniversalItem current2 in @object.Items)
                    {
                        BarButtonItem barButtonItem2 = new BarButtonItem(Customizable.BarManager, current2.Name)
                        {
                            Tag = current2
                        };
                        barButtonItem2.ItemClick += new ItemClickEventHandler(this.CompletionParameterButton_ItemClick);
                        list.Add(barButtonItem2);
                    }
                }
            }
            return list;
        }

        private Image GetCompletionParameterIcon(TaskCompletionParameter parameter)
        {
            if (parameter.IconIco != null)
            {
                return parameter.IconIco.ToBitmap();
            }
            return parameter.Icon;
        }
        private PopupMenu CreateCompletionParameterPopupMenu(IEnumerable<BarButtonItem> buttons)
        {
            PopupMenu popupMenu = new PopupMenu(Customizable.BarManager);
            popupMenu.AllowRibbonQATMenu = false;
            if (buttons != null && buttons.Count<BarButtonItem>() > 0)
            {
                popupMenu.AddItems(buttons.ToArray<BarButtonItem>());
            }
            return popupMenu;
        }

        private void CompletionParameterItem_ItemClick(object sender, ItemClickEventArgs e)
        {
            try
            {
                TaskCompletionParameter taskCompletionParameter = e.Item.Tag as TaskCompletionParameter;
                if (taskCompletionParameter != null)
                {
                    BuiltInBranch builtInBranch = null;
                    if (this.Task.SystemInfo.State.BuiltInState == Task.StartedState.Id)
                    {
                        builtInBranch = Task.NotStartedToCompletedByComplete;
                    }
                    else
                    {
                        if (this.Task.SystemInfo.State.BuiltInState == Task.InWorkState.Id)
                        {
                            builtInBranch = Task.InWorkToCompletedByComplete;
                        }
                        else
                        {
                            if (this.Task.SystemInfo.State.BuiltInState == Task.ReturnFromTheDelegationState.Id)
                            {
                                builtInBranch = Task.ReturnFromTheDelegationToCompletedByComplete;
                            }
                        }
                    }
                    if (builtInBranch != null)
                    {
                        StatesStateMachineBranch statesStateMachineBranch = StateService.FindBranchByBuiltIn(builtInBranch, this.Task.SystemInfo.State);
                        if (statesStateMachineBranch != null)
                        {
                            this.completeTaskByCompletionParameterLogMessage = string.Format(@"Completion parameter: {0}", e.Item.Caption);
                            this.currentCompletionParameter = taskCompletionParameter;
                            this.TaskService.SetTaskCompletionResult(this.Task, taskCompletionParameter);
                            StatesState state = this.Task.SystemInfo.State;
                            CardControl.ChangeState(statesStateMachineBranch);
                            if (this.Task != null && this.Task.SystemInfo.State == state)
                            {
                                this.Task.MainInfo.CompletionResult = null;
                            }
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                this.ProcessException(ex);
            }
        }
        private void CompletionParameterButton_ItemClick(object sender, ItemClickEventArgs e)
        {
            try
            {
                System.Collections.IList section = this.Task.GetSection(this.TaskSetting.Completion.TaskCompletionParametersSetting.DisplayFieldSectionId);
                if (section != null)
                {
                    if (section.Count == 0)
                    {
                        section.Add(new BaseCardSectionRow());
                    }
                    SectionField field = this.MetadataProvider.GetField(this.TaskSetting.Completion.TaskCompletionParametersSetting.DisplayFieldId);
                    if (e.Item.Tag is FieldEnumValue)
                    {
                        (section[0] as BaseCardSectionRow)[field.Name] = ((FieldEnumValue)e.Item.Tag).Value;
                    }
                    else
                    {
                        if (e.Item.Tag is BaseUniversalItem)
                        {
                            (section[0] as BaseCardSectionRow)[field.Name] = MyContext.GetObjectRef<BaseUniversalItem>(e.Item.Tag as BaseUniversalItem).Id;
                        }
                    }
                    BuiltInBranch builtInBranch = null;
                    if (this.Task.SystemInfo.State.BuiltInState == Task.StartedState.Id)
                    {
                        builtInBranch = Task.NotStartedToCompletedByComplete;
                    }
                    else
                    {
                        if (this.Task.SystemInfo.State.BuiltInState == Task.InWorkState.Id)
                        {
                            builtInBranch = Task.InWorkToCompletedByComplete;
                        }
                        else
                        {
                            if (this.Task.SystemInfo.State.BuiltInState == Task.ReturnFromTheDelegationState.Id)
                            {
                                builtInBranch = Task.ReturnFromTheDelegationToCompletedByComplete;
                            }
                        }
                    }
                    if (builtInBranch != null)
                    {
                        StatesStateMachineBranch statesStateMachineBranch = StateService.FindBranchByBuiltIn(builtInBranch, this.Task.SystemInfo.State);
                        if (statesStateMachineBranch != null)
                        {
                            this.completeTaskByCompletionParameterLogMessage = string.Format(@"Completion parameter: {0}",e.Item.Caption);
                            this.currentCompletionParameter = this.TaskService.GetCompletionParameters(this.Task).First<TaskCompletionParameter>();
                            this.TaskService.SetTaskCompletionResult(this.Task, this.currentCompletionParameter);
                            CardControl.ChangeState(statesStateMachineBranch);
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                this.ProcessException(ex);
            }
        }
    }
}