BuYuHouDuan/UserSrc/UserApi/User/UserController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Common;
using Common.CommonModel;
using CommonInfrastructure;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using UserDomain.Entity;
using UserService.Param;
using UserService.User;
using UserService.User.Response;

namespace UserApi.User
{
    [ApiController, Route("api/[controller]")]
    [Authorize]
    public class UserController : BaseController
    {
        private readonly IUserService _userService;

        public UserController(IUserService userService)
        {
            _userService = userService;
        }

        [HttpGet("RealNameAuth")]
        [Authorize]
        public async Task<BaseResponse<string>> RealNameAuth(string realName, string idCard)
        {
            var result = await _userService.RealNameAuth(idCard, realName, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("UpdateUserName")]
        [Authorize]
        public async Task<BaseResponse<string>> UpdateUserName(string userName)
        {
            var result = await _userService.UpdateUserName(userName, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("BindWX")]
        [Authorize]
        public async Task<BaseResponse<string>> BindWX(string openId)
        {
            var result = await _userService.BindWX(openId, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("BindMobile")]
        [Authorize]
        public async Task<BaseResponse<string>> BindMobile(string mobile, string code)
        {
            var result = await _userService.BindMobile(mobile, code, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("UpdateAvatar")]
        [Authorize]
        public async Task<BaseResponse<string>> UpdateAvatar(string avatarUrl)
        {
            var result = await _userService.UpdateAvatar(avatarUrl, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("UpdateAvatarFrame")]
        [Authorize]
        public async Task<BaseResponse<string>> UpdateAvatarFrame(string avatarFrame)
        {
            var result = await _userService.UpdateAvatarFrame(avatarFrame, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("GetUser")]
        [Authorize]
        public async Task<BaseResponse<UserEntity>> GetUser(string userid)
        {
            var result = await _userService.GetUser(userid);
            if (result == null)
                return this.ToFailResult<UserEntity>("用户不存在");
            return this.ToResult(result);
        }

        [HttpGet("GetUserAssets")]
        public async Task<BaseResponse<UserAssetsResponse>> GetUserAssets()
        {
            var user = await _userService.GetUser(loginUser.UserId);
            return this.ToResult(new UserAssetsResponse
            {
                Gold = user.Assets.Gold,
                Diamond = user.Assets.Diamond,
                Props = user.Props
            });
        }

        [HttpPost("GetUserList")]
        [Authorize]
        public async Task<PageResponse<UserListItemDto>> GetUserList(BaseListPageParam param)
        {
            var result = await _userService.GetUserList(param);
            var dtos = result.list.Select(u => new UserListItemDto
            {
                Id = u.Id,
                Number = u.BaseInfo?.Number ?? "",
                UserName = u.BaseInfo?.UserName ?? "",
                AvatarUrl = u.BaseInfo?.AvatarUrl ?? "",
                Mobile = u.BaseInfo?.Mobile ?? "",
                CreateTime = u.CreateTime
            });
            return this.ToPageResult(dtos, (int)result.count);
        }

        [HttpPost("SendEmail")]
        [Authorize]
        public async Task<BaseResponse<string>> SendEmail(SendEmailParam param)
        {
            var result = await _userService.SendEmail(param, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("GetEmail")]
        [Authorize]
        public async Task<BaseResponse<EmailDto>> GetEmail(string id)
        {
            var result = await _userService.GetEmail(id, loginUser);
            if (result == null)
                return this.ToFailResult<EmailDto>("邮件不存在");

            var dto = new EmailDto
            {
                Id = result.Id,
                Title = result.Title,
                Content = result.Content,
                SendTime = result.SendTime,
                ReadTime = result.ReadTime,
                IsRead = result.IsRead,
                IsReward = result.IsReward,
                RewardDiamond = result.RewardDiamond,
                RewardGold = result.RewardGold,
                RewardItems = result.RewardItems,
                ExpireTime = result.ExpireTime
            };
            return this.ToResult(dto);
        }

        [HttpGet("RewardEmail")]
        [Authorize]
        public async Task<BaseResponse<RewardEmailResponse>> RewardEmail(int type, string? id = "")
        {
            var result = await _userService.RewardEmail(type, id, loginUser);
            if (result.isok)
                return this.ToResult(result.model);
            else
                return this.ToFailResult<RewardEmailResponse>(result.msg);
        }

        [HttpGet("DeleteEmail")]
        [Authorize]
        public async Task<BaseResponse<string>> DeleteEmail(int type, string? id = "")
        {
            var result = await _userService.DeleteEmail(type, id, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("ReadEmailMore")]
        [Authorize]
        public async Task<BaseResponse<string>> ReadEmailMore()
        {
            var result = await _userService.ReadEmailMore(loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpGet("GetNoReadCount")]
        [Authorize]
        public async Task<BaseResponse<long>> GetNoReadCount()
        {
            var result = await _userService.GetNoReadCount(loginUser);
            return this.ToResult(result);
        }

        [HttpPost("GetEmailByPage")]
        [Authorize]
        public async Task<PageResponse<UserEmail>> GetEmailByPage(GetEmailPageParam param)
        {
            var result = await _userService.GetEmailByPage(param, loginUser);
           
            return this.ToPageResult(result.list, (int)result.count);
        }


        [HttpGet("GetFishingReturnInfo")]
        [Authorize]
        public async Task<BaseResponse<FishingReturnDto>> GetFishingReturnInfo()
        {
            var result = await _userService.GetFishingReturnInfo(loginUser);
            var dto = new FishingReturnDto
            {
                TodayConsume = result.TodayConsume,
                YesterdayConsume = result.YesterdayConsume,
                IsClaimed = result.IsClaimed,
                CanClaimGold = result.CanClaimGold
            };
            return this.ToResult(dto);
        }

        [HttpGet("ClaimFishingReturn")]
        [Authorize]
        public async Task<BaseResponse<ClaimFishingReturnDto>> ClaimFishingReturn()
        {
            var result = await _userService.ClaimFishingReturn(loginUser);
            if (result.isok)
            {
                return this.ToResult(new ClaimFishingReturnDto
                {
                    Gold = result.gold,
                    Message = result.msg
                });
            }
            else
            {
                return this.ToFailResult<ClaimFishingReturnDto>(result.msg);
            }
        }

    }

    public class UserDto
    {
        public string Id { get; set; }

        public string Number { get; set; }

        public string UserName { get; set; }

        public string AvatarUrl { get; set; }

        public string Mobile { get; set; }

        public int Diamond { get; set; }

        public long Gold { get; set; }

        public int VipLevel { get; set; }

        public long CreateTime { get; set; }
    }

    public class UserListItemDto
    {
        public string Id { get; set; }

        public string Number { get; set; }

        public string UserName { get; set; }

        public string AvatarUrl { get; set; }

        public string Mobile { get; set; }

        public long CreateTime { get; set; }
    }

    public class EmailDto
    {
        public string Id { get; set; }

        public string Title { get; set; }

        public string Content { get; set; }

        public long SendTime { get; set; }

        public long ReadTime { get; set; }

        public bool IsRead { get; set; }

        public bool IsReward { get; set; }

        public int RewardDiamond { get; set; }

        public long RewardGold { get; set; }

        public List<CommonDomain.BaseModel.BaseProductCount> RewardItems { get; set; }

        public long ExpireTime { get; set; }
    }

    public class FishingReturnDto
    {
        public long TodayConsume { get; set; }

        public long YesterdayConsume { get; set; }

        public bool IsClaimed { get; set; }

        public long CanClaimGold { get; set; }
    }

    public class ClaimFishingReturnDto
    {
        public long Gold { get; set; }

        public string Message { get; set; }
    }

    public class UserAssetsResponse
    {
        public long Gold { get; set; }
        public int Diamond { get; set; }
        public List<CommonDomain.BaseModel.BaseProductCount> Props { get; set; }
    }
}