StaffPerformance/wispro.sp.web/Pages/Welcome.razor.cs

using System.Threading.Tasks;
using wispro.sp.web.Models;
using wispro.sp.web.Services;
using Microsoft.AspNetCore.Components;
using wispro.sp.web.Components;
using System.Collections.Generic;
using wispro.sp.entity;
using System.Text.Json;
using AntDesign;
using System;

namespace wispro.sp.web.Pages
{
    public partial class Welcome
    {
        private readonly EditableLink[] _links =
        {
            new EditableLink {Title = "Operation 1", Href = ""},
            new EditableLink {Title = "Operation 2", Href = ""},
            new EditableLink {Title = "Operation 3", Href = ""},
            new EditableLink {Title = "Operation 4", Href = ""},
            new EditableLink {Title = "Operation 5", Href = ""},
            new EditableLink {Title = "Operation 6", Href = ""}
        };

        private ActivitiesType[] _activities = { };
        private NoticeType[] _projectNotice = { };
        private CurrentUser _CurrentUser;
        private List<AppealRecord> AppealRecords = new List<AppealRecord>();

        [Inject] public IProjectService ProjectService { get; set; }
        [Inject] public IUserService _userService { get; set; }

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

        protected override async System.Threading.Tasks.Task OnInitializedAsync()
        {
            await base.OnInitializedAsync();
            _CurrentUser = _userService.CurrentUser;
            _projectNotice = await ProjectService.GetProjectNoticeAsync();
            //_activities = await ProjectService.GetActivitiesAsync();
            AppealRecords = await _atService.GetUserAppeals(_CurrentUser.Userid);

            AppealRecords.Sort((a, b) =>
            {
                var sd = (a.ReviewTime == null) ? a.ReviewTime : a.CreateTime;
                var ed = (b.ReviewTime == null) ? b.ReviewTime : b.CreateTime;

                if (ed > sd)
                {
                    return 1;
                }
                else
                {
                    return -1;
                }
                
            });

            foreach (AppealRecord at in AppealRecords)
            {
                System.Diagnostics.Debug.WriteLine(at.Item.CaseNo);
            }
        }

        async Task ShowModel(AppealRecord appealRecord)
        {
            
            var templateOptions = new Models.ReviewerAppealModel();
            await templateOptions.Init(_atService, appealRecord.Id);

            var modalConfig = new ModalOptions();
            modalConfig.Title = $"{appealRecord.Type.Name}审核" ;
            modalConfig.Width = 650;
            //modalConfig.Footer = null;
            modalConfig.DestroyOnClose = true;


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

            _modalRef.OnOpen = () =>
            {
                Console.WriteLine("ModalRef OnOpen");
                return Task.CompletedTask;
            };

            _modalRef.OnOk = async () =>
            {
                Console.WriteLine(JsonSerializer.Serialize(templateOptions));
                try
                {
                    await _atService.ReviewerAppeal(templateOptions);
                    await _modalRef.CloseAsync();

                }
                catch (Exception ex)
                {
                    //_ErrorMessage = ex.Message;
                }

                //return Task.CompletedTask;
            };

            _modalRef.OnCancel = () =>
            {
                Console.WriteLine("ModalRef OnCancel");
                return Task.CompletedTask;
            };

            _modalRef.OnClose = () =>
            {
                Console.WriteLine("ModalRef OnClose");
                return Task.CompletedTask;
            };
            StateHasChanged();
        }
    }
}