public async Task <IActionResult> CommentConsumptionAsync([FromBody] CommentConsumptionRequestDto requestDto)
{
var consumptionBiz = new ConsumptionBiz();
var consumptionModel = await consumptionBiz.GetModelAsync(requestDto.ConsumptionGuid);
if (consumptionModel == null)
{
return(Failed(ErrorCode.Empty, "未查询到该消费记录"));
}
var goodsItemModel = await new GoodsItemBiz().GetModelAsync(consumptionModel.FromItemGuid);
var projectModel = await new ProjectBiz().GetModelAsync(goodsItemModel?.ProjectGuid);
var commentModel = new CommentModel
{
CommentGuid = Guid.NewGuid().ToString("N"),
TargetGuid = goodsItemModel?.ProjectGuid,
Content = requestDto.Content,
Score = requestDto.Score,
Anonymous = requestDto.Anonymous,
CreatedBy = UserID,
LastUpdatedBy = UserID,
OrgGuid = string.Empty
};
consumptionModel.CommentGuid = commentModel.CommentGuid;
consumptionModel.IsComment = true;
var result = await consumptionBiz.CommentConsumptionAsync(consumptionModel, commentModel);
return(result ? Success() : Failed(ErrorCode.DataBaseError, "评价失败"));
}
/// <summary>
/// 用户预约的服务完成后发送微信模板消息通知
/// </summary>
/// <param name="consumptionGuid"></param>
private void NotifyUser(string consumptionGuid)
{
Task.Run(() =>
{
if (string.IsNullOrWhiteSpace(PlatformSettings.UserAppointmentCompletedNotificationTemplate))
{
return;
}
var userOpenId = "";
string controllerName = ControllerContext.ActionDescriptor.ControllerName;
string actionName = ControllerContext.ActionDescriptor.ActionName;
try
{
var model = new ConsumptionBiz().GetModel(consumptionGuid);
var userModel = new UserBiz().GetModelAsync(model.UserGuid).Result;
Logger.Debug($"NotifyUser-用户预约的服务已完成-用户openid-{userModel?.WechatOpenid}");
if (string.IsNullOrWhiteSpace(userModel?.WechatOpenid ?? ""))
{
return;
}
var merchantModel = new MerchantBiz().GetAsync(model.MerchantGuid).Result;
var projectModel = new ProjectBiz().GetAsync(model.ProjectGuid).Result;
var resToken = WeChartApi.GetAccessToken(PlatformSettings.CDClientAppId, PlatformSettings.CDClientAppSecret).Result;
Logger.Debug($"NotifyUser-用户预约的服务已完成-获取token-{JsonConvert.SerializeObject(resToken)}");
if (string.IsNullOrWhiteSpace(resToken.AccessToken))
{
Common.Helper.Logger.Error($"GD.API.Controllers.Consumer.{controllerName}.{actionName} openId:[{userOpenId}] {Environment.NewLine} error:用户预约后发送模板消息通知云医执行端公众号-获取token失败。{resToken.Errmsg}");
return;
}
userOpenId = userModel.WechatOpenid;
var clientMsg = new WeChatTemplateMsg
{
Touser = userModel.WechatOpenid,
Template_Id = PlatformSettings.UserAppointmentNotificationTemplate,
Data = new
{
First = new { Value = "【您预约的服务已完成】" },
//完成时间
Keyword1 = new { Value = $"{model.ConsumptionEndDate.Value.ToString("MM月dd日 HH:mm")}" },
//服务项目
Keyword2 = new { Value = projectModel?.ProjectName },
//服务门店
Keyword3 = new { Value = merchantModel.MerchantName },
//备注
Remark = new { Value = "如对我们服务有什么建议，请及时与我们联系" },
}
};
var clientTempMsgRes = WeChartApi.SendTemplateMsg(clientMsg, resToken.AccessToken);
Logger.Debug($"NotifyUser-用户预约的服务已完成-发送模板消息-{JsonConvert.SerializeObject(clientTempMsgRes)}");
}
catch (Exception ex)
{
Logger.Error($"GD.API.Controllers.Consumer.{controllerName}.{actionName} openId:[{userOpenId}] {Environment.NewLine} error:用户预约服务完成后发送模板消息通知云医用户端公众号端失败。{ex.Message}");
}
});
}
public async Task <IActionResult> CancelOppointmentAsync([FromBody] UpdateOppointmentStatusRequestDto requestDto)
{
var consumptionBiz = new ConsumptionBiz();
var model = consumptionBiz.GetModel(requestDto.ConsumptionGuid);
if (model == null || string.IsNullOrWhiteSpace(model.ConsumptionGuid))
{
return(Failed(ErrorCode.Empty, "找不到该预约记录！"));
}
if (!model.ConsumptionStatus.Equals(ConsumptionStatusEnum.Booked.ToString()))
{
return(Failed(ErrorCode.UserData, "该预约记录的状态不支持取消，请检查！"));
}
var projectModel = await new ProjectBiz().GetAsync(model.ProjectGuid);
var categoryExtensionModel = await new MerchantCategoryBiz().GetModelByClassifyGuidAsync(projectModel.ClassifyGuid, projectModel.MerchantGuid);
var limitTime = (categoryExtensionModel?.LimitTime) ?? 30;
if (requestDto.FromPoint == "Consumer")
{
if (DateTime.Now >= model.AppointmentDate)
{
return(Failed(ErrorCode.UserData, $"当前已过预约时间，请联系门店处理！"));
}
else if ((model.AppointmentDate - DateTime.Now).TotalMinutes < limitTime)
{
return(Failed(ErrorCode.UserData, $"当前离到店服务时间不足{limitTime}分钟，不可取消，请联系门店处理！"));
}
}
model.ConsumptionStatus = ConsumptionStatusEnum.Canceled.ToString();
model.LastUpdatedBy = UserID;
model.LastUpdatedDate = DateTime.Now;
//取消预约 须在个人产品数量上+1
var goodsItemModel = await new GoodsItemBiz().GetAsync(model.FromItemGuid);
if (goodsItemModel == null)
{
return(Failed(ErrorCode.Empty, "找不到该记录的个人商品项！"));
}
goodsItemModel.Remain++;
goodsItemModel.Used--;
goodsItemModel.Available = goodsItemModel.Remain > 0;
//删除预约所占时间
var merchantScheduleDetailModel = await new MerchantScheduleDetailBiz().GetModelAsyncByConsumptionGuid(model.ConsumptionGuid);
if (merchantScheduleDetailModel == null)
{
return(Failed(ErrorCode.Empty, "找不到该预约所占用时间！"));
}
var isSuccess = await consumptionBiz.CancelOppointment(model, goodsItemModel, merchantScheduleDetailModel);
return(Success(isSuccess));
}
public IActionResult ChangeAppointmentStatus([FromBody] ChangeAppointmentStatusRequestDto requestDto)
{
var model = new ConsumptionBiz().GetModel(requestDto.ConsumptionGuid);
if (model == null)
{
return(Failed(ErrorCode.Empty, "没找到该预约信息！"));
}
var isSuccess = false;
switch (requestDto.ConsumptionStatus)
{
case ConsumptionStatusEnum.Canceled:
if (!model.ConsumptionStatus.Equals(ConsumptionStatusEnum.Booked.ToString()))
{
return(Failed(ErrorCode.UserData, "该预约记录的状态不支持取消，请检查！"));
}
//取消预约 须在个人产品数量上+1
isSuccess = ChangeStatus(model, ConsumptionStatusEnum.Canceled);
break;
case ConsumptionStatusEnum.Arrive:
if (!model.ConsumptionStatus.Equals(ConsumptionStatusEnum.Booked.ToString()))
{
return(Failed(ErrorCode.UserData, "该预约记录的状态不支持取消，请检查！"));
}
isSuccess = ChangeStatus(model, ConsumptionStatusEnum.Arrive);
break;
case ConsumptionStatusEnum.Completed:
if (!model.ConsumptionStatus.Equals(ConsumptionStatusEnum.Arrive.ToString()))
{
return(Failed(ErrorCode.UserData, "该预约记录的状态不支持取消，请检查！"));
}
isSuccess = ChangeStatus(model, ConsumptionStatusEnum.Arrive);
break;
default:
return(Failed(ErrorCode.UserData, "该预约记录的状态不支持该操作，请检查！"));
}
return(Success(isSuccess));
}
public async Task <IActionResult> CompleteConsumption([FromBody] CompleteConsumptionRequestDto requestDto)
{
var model = new ConsumptionBiz().GetModel(requestDto.ConsumptionGuid);
if (model == null)
{
return(Failed(ErrorCode.Empty, "没找到该预约信息！"));
}
if (!string.Equals(model.ConsumptionStatus.ToString(), ConsumptionStatusEnum.Arrive.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(Failed(ErrorCode.UserData, "该消费记录不处于[已到店开始]状态，不能执行开始操作"));
}
model.MerchantRemark = requestDto.MerchantRemark;
model.ConsumptionStatus = ConsumptionStatusEnum.Completed.ToString();
model.ConsumptionEndDate = DateTime.Now;
model.LastUpdatedBy = UserID;
model.LastUpdatedDate = DateTime.Now;
var result = await new ConsumptionBiz().UpdateAsync(model);
NotifyUser(model.ConsumptionGuid);
return(result ? Success() : Failed(ErrorCode.DataBaseError, "完成操作失败"));
}
public async Task <IActionResult> SetMissStautsForConsumptionAsync(string consumptionGuid)
{
var consumptionBiz = new ConsumptionBiz();
var model = consumptionBiz.GetModel(consumptionGuid);
if (model == null)
{
return(Failed(ErrorCode.Empty, "没找到该预约信息！"));
}
if (!string.Equals(model.ConsumptionStatus.ToString(), ConsumptionStatusEnum.Booked.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(Failed(ErrorCode.UserData, "该预约记录不处于[已预约]状态，不能修改状态为[已错过]"));
}
if (DateTime.Now < model.AppointmentDate)
{
return(Failed(ErrorCode.UserData, "当前还未到预约的时间，不能修改预约记录状态为[已错过]"));
}
model.LastUpdatedBy = UserID;
model.LastUpdatedDate = DateTime.Now;
var result = await consumptionBiz.UpdateAsync(model);
return(result ? Success() : Failed(ErrorCode.DataBaseError, "修改预约记录状态为[已错过]失败"));
}
public async Task <IActionResult> StartConsumption(string consumptionGuid)
{
var consumptionBiz = new ConsumptionBiz();
var model = consumptionBiz.GetModel(consumptionGuid);
if (model == null)
{
return(Failed(ErrorCode.Empty, "没找到该预约信息！"));
}
var checkWorking = await consumptionBiz.CheckHasWorkingConsumptionAsync(model.OperatorGuid);
if (checkWorking)
{
return(Failed(ErrorCode.UserData, "尚有服务正在进行中，请先完成进行中的服务"));
}
if (!string.Equals(model.ConsumptionStatus.ToString(), ConsumptionStatusEnum.Booked.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(Failed(ErrorCode.UserData, "该消费记录不处于[已预约]状态，不能执行开始操作"));
}
var result = ChangeStatus(model, ConsumptionStatusEnum.Arrive);
return(result ? Success() : Failed(ErrorCode.DataBaseError, "开始操作失败"));
}
