StaffPerformance/wispro.sp.web/Pages/AppCase/MyCaselist.razor.cs

using AntDesign;
using AntDesign.ProLayout;
using AntDesign.TableModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using Microsoft.Extensions.Configuration;
using Microsoft.JSInterop;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using wispro.sp.entity;
using wispro.sp.share;
using wispro.sp.web.Models;
using wispro.sp.web.Services;


namespace wispro.sp.web.Pages.AppCase
{
    [Authorize]
    public partial class MyCaselist
    {
        const string strAgentFeedbackMemo = "AgentFeedbackMemo";
        const string strDoItemCoefficient = "DoItemCoefficient";
        const string strReturnCasseNo = "ReturnCasseNo";
        const string strCaseCoefficient = "CaseCoefficient";
        const string strWordCount = "WordCount";

        public TableFilter<string>[] CaseCoeFilters = new TableFilter<string>[] {
            new() { Text = "S", Value = "S" },
            new() { Text = "A", Value = "A" },
            new() { Text = "B", Value = "B" },
            new() { Text = "C", Value = "C" },
            new() { Text = "D", Value = "D" }
        };

        [Inject]
        protected AppealTypeService apTypeService { get; set; }

        private List<PerformanceItem> _Datas;
        private List<StaffStatistics> MyStatistics;
        IEnumerable<PerformanceItem> selectedItems = new List<PerformanceItem>();
        private CalMonth HandlingCalMonth;


        int _pageIndex = 1;
        int _pageSize = 10;
        int _total;
        bool _loading = false;
        PerformanceItem EditingItem = null;
        bool _visible = false;
        bool _isAdd = false;

        List<TabPaneItem> tabList = new List<TabPaneItem>() {
            new TabPaneItem(){ Key ="myList", Tab ="本月待确认绩效" },
            new TabPaneItem(){  Key ="myAll", Tab ="往期已计算绩效"},
        };

        [Inject] public PerformanceItemServices _ItemService { get; set; }
        [Inject] public MessageService _message { get; set; }
        [Inject] protected NavigationManager NavigationManager { get; set; }
        [Inject] protected IUserService _userService { get; set; }

        [Inject] protected CalMonthServices _CalMonthService { get; set; }
        [Inject] protected IJSRuntime JSRuntime { get; set; }

        [Inject] IConfiguration configuration{get;set;}


        private bool isFirstInit = true;
        private Table<PerformanceItem> table;
        private CurrentUser _user;
        private string strAddProjectJX = "";
        
        protected async override Task OnInitializedAsync()
        {
            if (isFirstInit)
            {
                _loading = true;
                await RefreshMyStatistics();
                _Datas = new List<PerformanceItem>();// data.Results;
                _total = 0;//data.TotalCount;
                _loading = false;
            }

            isFirstInit = false;
            await apTypeService.GetItems();
            _user = await _userService.GetUser();
            StateHasChanged();
        }

        private bool ShowMenu()
        {
            var strlfd = configuration.GetValue<string>("Latest_feedback_date");

            if (string.IsNullOrEmpty(strlfd))
            {
                return true;
            }
            else
            {
                if(DateTime.Now.Day <= int.Parse(strlfd))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        private async Task RefreshMyStatistics()
        {
            var HandlingCalMonth = await _CalMonthService.GetHandlingMonth();
            if (HandlingCalMonth != null)
            {
                var _user = await _userService.GetUser(); ;
                if (_user.Userid != null)
                {
                    MyStatistics = await _ItemService.CalMyStatistics(HandlingCalMonth.Year, HandlingCalMonth.Month, _user.Userid.Value);
                }
                else
                {
                    NavigationManager.NavigateTo("/LoginPages");
                }
            }

        }

        private string GetStatistics(string strType, bool isBasePoint = false)
        {
            try
            {
                if (strType != "ALL")
                {

                    var tem = MyStatistics.Where<StaffStatistics>(s => s.jxType == strType).FirstOrDefault();

                    if (isBasePoint)
                    {
                        if (tem != null)
                        {
                            return (tem.totalBasePoint.HasValue ? tem.totalBasePoint.Value.ToString("0.00") : "");
                        }
                        else
                        {
                            return "";
                        }
                    }
                    else
                    {
                        if (tem != null)
                        {
                            return (tem.totalActuallyPoint.HasValue ? tem.totalActuallyPoint.Value.ToString("0.00") : "");
                        }
                        else
                        {
                            return "";
                        }
                    }

                }
                else
                {
                    if (isBasePoint)
                    {
                        return MyStatistics.Select(s => s.totalBasePoint.Value).Sum().ToString("0.00");
                    }
                    else
                    {
                        return MyStatistics.Select(s => s.totalActuallyPoint.Value).Sum().ToString("0.00");
                    }
                }
            }
            catch
            {
                return "";
            }
        }

        private int serialNumber(int pageIndex, int pageSize, int id)
        {
            int iIndex = 0;
            foreach (PerformanceItem sf in _Datas)
            {
                iIndex++;

                if (sf.Id == id)
                {
                    break;
                }
            }
            return (pageIndex - 1) * pageSize + iIndex;
        }


        private async Task HandleTableChange(QueryModel<PerformanceItem> queryModel)
        {
            var _user = await _userService.GetUser();
            if (_CurrentKey == tabList[0].Key)
            {
                _loading = true;

                var data = await _ItemService.Query(_user.Userid.Value, jxType.doing, queryModel);

                _Datas = data.Results;
                _total = data.TotalCount;
                _loading = false;
                StateHasChanged();
            }
            else
            {
                _loading = true;
                var data = await _ItemService.Query(_user.Userid.Value, jxType.finished, queryModel);

                _Datas = data.Results;
                _total = data.TotalCount;
                _loading = false;
                StateHasChanged();
            }


        }
        
        [Inject] IConfiguration _configuration { get; set; }

        bool isDownloading = false;
        private async Task ExportDataAsync(jxType jxType)
        {
            isDownloading = true;
            var fileData =await  _ItemService.ExportData(_user.Userid.Value, jxType);

            while(!fileData.Finished)
            {
                fileData =await  _ItemService.getExportDataProcessing(fileData.Id);
                await Task.Delay(20);
            }

            NavigationManager.NavigateTo($"{_configuration.GetValue<string>("APIUrl")}FileProcesTask/Download?Id={fileData.Id}");

            isDownloading = false;

        } 

        private void OnsubShensu(PerformanceItem Item)
        {
            EditingItem = Item;
            _visible = true;

            //return new EventCallback();
        }

        bool _ShowJXModal = false;
        private void OnJXCal(PerformanceItem Item)
        {
            EditingItem = Item;
            _ShowJXModal = true;
        }

        private async void menuYSJXClick(PerformanceItem Item)
        {
            var respone = await _ItemService.SaveFieldChange(Item.Id, strAgentFeedbackMemo, "已算绩效");
            var item = await _ItemService.GetPerformancItem(Item.Id);
            Item.BasePoint = item.BasePoint;
            _ = RefreshMyStatistics();
        }

        private shensuType _SelectedItem;
        private void OnSelectedItemChangedHandler(shensuType value)
        {
            _SelectedItem = value;
            //StaffGradeIdChanged.InvokeAsync(_SelectedItem.Id);
        }

        #region 特殊绩效字段选择框变更时处理代码
        async void SelectChanged(Reason  value)
        {
            if (!_loading && EditingItem != null)
            {
                var respone =await _ItemService.SaveFieldChange(EditingItem.Id, strAgentFeedbackMemo, EditingItem.AgentFeedbackMemo);
                var item = await _ItemService.GetPerformancItem(EditingItem.Id) ;
                EditingItem.BasePoint = item.BasePoint;
                _ = RefreshMyStatistics();
                
                EditingItem = null;
                //table.ReloadData();
            }
        }

        void ClearSelect(int itemId)
        {
            var respone = _ItemService.SaveFieldChange(itemId, strAgentFeedbackMemo,"");
            EditingItem = null;

            _ = RefreshMyStatistics();
            table.ReloadData();
        }
        #endregion

        Dictionary<string, object> OnRow(RowData<PerformanceItem> row)
        {
            Dictionary<string, object> ret = new Dictionary<string, object>();

            
            ret.Add("onclick", ((Action)delegate
            {
                EditingItem = row.Data;
            }));


            return ret;
        }

        void OnFocus(PerformanceItem item)
        {
            EditingItem = item;
        }

        string _CurrentKey = "myList";
        void OnTabChange(string key)
        {
            _CurrentKey = key;
            table.ReloadData();
            StateHasChanged();
        }

        private ModalRef _modalRef;
        [Inject] ModalService _ModalService { get; set; }
        [Inject]protected AppealTypeService _atService { get; set; }

        
        async Task ShowModel(PerformanceItem Item,AppealType appealType)
        {
            var templateOptions = new Models.CreateAppealModel();
            await templateOptions.Init(_atService,Item, appealType);

            var modalConfig = new ModalOptions();
            modalConfig.Title = appealType.Name;
            modalConfig.Width = 650;
            //modalConfig.Footer = null;
            modalConfig.DestroyOnClose = true;
            modalConfig.MaskClosable = false;


            _modalRef = await _ModalService
                .CreateModalAsync<Components.CreateAppeal, Models.CreateAppealModel>(modalConfig, templateOptions);

            _modalRef.OnOpen = () =>
            {
                return Task.CompletedTask;
            };

            _modalRef.OnOk = async () =>
            {
                try
                {
                    await _atService.CreateAppeal(templateOptions);
                    await _modalRef.CloseAsync();

                    StateHasChanged();

                    var SuccessConfig = new ConfirmOptions()
                    {
                        Content = @"保存申诉信息成功！"
                    };

                    //modalConfig.Footer = null;
                    modalConfig.DestroyOnClose = true;
                    _ModalService.Success(SuccessConfig);

                }
                catch (Exception ex)
                {
                    _ModalService.Error(new ConfirmOptions()
                    {
                        Title = "保存申诉信息错误",
                        Content = ex.Message,
                    });
                    //_ErrorMessage = ex.Message;
                }

                //return Task.CompletedTask;
            };

            _modalRef.OnCancel = () =>
            {
                return Task.CompletedTask;
            };

            _modalRef.OnClose = () =>
            {
                return Task.CompletedTask;
            };
            StateHasChanged();
        }
    }
}