/// <summary>
/// 获取需要支付的价格
/// </summary>
public Tuple <ServiceResult, decimal> GetPayPrice(UserRightsOrderInput orderInput)
{
var result = ServiceResult.Success;
if (orderInput.OpenType == UserRightOpenType.OpenToOtherByRight)
{
return(Tuple.Create(ServiceResult.Failure("帮他购买时无价格计算"), 0m));
}
if (orderInput.OpenType == UserRightOpenType.OpenToOtherByPay)
{
if (orderInput.User.Id == orderInput.BuyUser.Id)
{
return(Tuple.Create(ServiceResult.Failure("不能帮自己购买"), 0m));
}
var price = orderInput.BuyGrade.Price;
return(Tuple.Create(result, price));
}
else
{
if (orderInput.BuyGrade.Price <= orderInput.CurrentGrade.Price &&
orderInput.OpenType != UserRightOpenType.AdminOpenHightGrade)
{
return(Tuple.Create(ServiceResult.Failure("购买的等级不能低于当前等级"), 0m));
}
var findRight = orderInput.UserRightList.FirstOrDefault(r => r.GradeId == orderInput.BuyGrade.Id);
if (findRight != null && orderInput.OpenType != UserRightOpenType.AdminOpenHightGrade)
{
return(Tuple.Create(ServiceResult.Failure("用户当前等级权益已存在，不能重复购买"), 0m));
}
var userRightsConfigs = Resolve <IAutoConfigService>().GetList <UserRightsConfig>();
var userGrades = Resolve <IAutoConfigService>().GetList <UserGradeConfig>();
// 如果包含，则为升级
if (userRightsConfigs.Select(r => r.GradeId).Contains(orderInput.User.GradeId))
{
if (orderInput.OpenType != UserRightOpenType.Upgrade &&
orderInput.OpenType != UserRightOpenType.AdminOpenHightGrade)
{
return(Tuple.Create(ServiceResult.Failure("开通方式有错,应该为自身升级"), 0m));
}
}
else
{
if (orderInput.OpenType != UserRightOpenType.OpenSelf)
{
return(Tuple.Create(ServiceResult.Failure("开通方式有错,应该为自身购买"), 0m));
}
}
// 计算价格
var price = orderInput.BuyGrade.Price;
if (orderInput.OpenType == UserRightOpenType.Upgrade)
{
price = orderInput.BuyGrade.Price - orderInput.CurrentGrade.Price;
}
if (price <= 0)
{
return(Tuple.Create(ServiceResult.Failure("购买等级价格设置为0"), 0m));
}
if (price != orderInput.Price)
{
return(Tuple.Create(ServiceResult.Failure("前后台计算价格不一样"), 0m));
}
return(Tuple.Create(result, price));
}
}
public Tuple <ServiceResult, Article> AddOrUpdate(Article model, HttpRequest request)
{
var id = request.Form["Id"];
var channelId = request.Form["ChannelId"];
if (!id.ToString().IsNullOrEmpty())
{
model.Id = id.ToString().ToSafeObjectId();
}
model.ChannelId = channelId.ToString().ToSafeObjectId();
var channel = Resolve <IChannelService>().GetSingle(r => r.Id == model.ChannelId);
if (channel == null)
{
Tuple.Create(ServiceResult.Failure("频道不存在"), new Article());
}
var list = Resolve <IChannelService>().DataFields(channelId.ToString());
var dic = new Dictionary <string, string>();
foreach (var item in list)
{
var key = item.Key;
string value = request.Form[key];
dic.Add(key, value);
}
var find = Resolve <IArticleAdminService>().GetSingle(u => u.Id == model.Id);
var result = true;
if (find == null)
{
model.RelationId = GetMaxRelationId();
result = Resolve <IArticleAdminService>().Add(model);
if (result)
{
}
}
else
{
result = Resolve <IArticleAdminService>().Update(model);
}
model.AttachValue = dic.ToJson();
// 如果为true
if (result)
{
// 添加标签和分类
var classType = Resolve <IChannelService>().GetChannelClassType(channel);
var classIds = request.Form["Classes"].ToStr();
var tagType = Resolve <IChannelService>().GetChannelTagType(channel);
var tagIds = request.Form["Tags"].ToStr();
Resolve <IRelationIndexService>()
.AddUpdateOrDelete(classType.FullName, model.RelationId, classIds);
Resolve <IRelationIndexService>()
.AddUpdateOrDelete(tagType.FullName, model.RelationId, tagIds);
return(Tuple.Create(ServiceResult.Success, new Article()));
}
DeleteCache();
return(Tuple.Create(ServiceResult.Failed, new Article()));
}
public ServiceResult Save(PrefertDataAutoForm view, long userId)
{
#region 安全验证
var user = Resolve <IUserService>().GetSingle(r => r.Id == userId);
if (user == null)
{
throw new ValidException("用户不存在");
}
var userDetail = Resolve <IUserDetailService>().GetSingle(r => r.UserId == user.Id);
if (userDetail == null)
{
throw new ValidException("用户数据不存在");
}
var userLevel = Resolve <IUserLevelService>().GetSingle(r => r.UserId == user.Id);
if (userLevel != null)
{
throw new ValidException("用户已完善资料或者数据不合理");
}
if (!RegexHelper.CheckEmail(view.Email))
{
throw new ValidException("邮箱格式不正确");
}
if (!RegexHelper.CheckPayPasswrod(view.PayPassword))
{
throw new ValidException("支付密码必须为6为数字");
}
#endregion 安全验证
var userLevelConfigList = Resolve <IAutoConfigService>().GetList <UserLevelConfig>();
var userLevelConfig = userLevelConfigList.FirstOrDefault(r => r.Price <= 0);
var result = ServiceResult.Success;
var context = Repository <IUserLevelRepository>().RepositoryContext;
try {
context.BeginTransaction();
userLevel = view.MapTo <UserLevel>();
userLevel.UserId = user.Id;
userLevel.ParentId = user.ParentId;
userLevel.Mobile = user.Mobile;
userLevel.Name = user.Name;
userLevel.LevelName = userLevelConfig?.Name;
userLevel.Status = UserLevelStatus.Activated;
Resolve <IUserLevelService>().Add(userLevel);
//userDetail.Avator = view.Avator;
//userDetail.PayPassword = view.PayPassword.ToMd5HashString();
Resolve <IUserDetailService>().Update(userDetail);
context.SaveChanges();
context.CommitTransaction();
} catch (Exception ex) {
context.RollbackTransaction();
result = ServiceResult.Failure(ex.Message);
} finally {
context.DisposeTransaction();
}
// 更新会员资料
if (result.Succeeded)
{
user.Email = view.Email;
user.Name = view.Name;
Ioc.Resolve <IUserService>().Update(user);
}
return(result);
}
/// <summary>
/// 增加或修改银行卡
/// </summary>
/// <param name="view"></param>
/// <returns></returns>
public ServiceResult AddOrUpdateBankCard(ApiBankCardInput view)
{
//银行卡必须为数字不能以0开头
var r = new Regex("^([1-9][0-9]*)$");
if (!r.IsMatch(view.BankCardId))
{
return(ServiceResult.Failure("请正确输入银行卡号"));
}
if (view.BankCardId.Length < 10)
{
return(ServiceResult.Failure("请正确输入银行卡号"));
}
if (view.Type == 0)
{
return(ServiceResult.Failure("请选择银行类型"));
}
#region 使用阿里接口判断银行卡是否正确
var checkUrl =
$"https://ccdcapi.alipay.com/validateAndCacheCardInfo.json?_input_charset=utf-8&cardNo={view.BankCardId}&cardBinCheck=true";
var httpRequest = (HttpWebRequest)WebRequest.CreateDefault(new Uri(checkUrl));
HttpWebResponse httpResponse = null;
try
{
httpResponse = (HttpWebResponse)httpRequest.GetResponse();
}
catch (WebException ex)
{
httpResponse = (HttpWebResponse)ex.Response;
}
var st = httpResponse.GetResponseStream();
var reader = new StreamReader(st, Encoding.GetEncoding("utf-8"));
var readResult = reader.ReadToEnd();
try
{
var aliResult = readResult.DeserializeJson <AliResult>();
if (aliResult.Validated != "true")
{
return(ServiceResult.Failure("请正确输入银行卡号"));
}
}
catch (Exception e)
{
return(ServiceResult.Failure("请正确输入银行卡号"));
}
#endregion 使用阿里接口判断银行卡是否正确
var bankCardList = Resolve <IBankCardService>().GetList(u => u.UserId == view.LoginUserId);
if (bankCardList.Count >= 10)
{
return(ServiceResult.Failure("银行卡最多只可绑定十张"));
}
var model = Resolve <IBankCardService>().GetSingle(u => u.Number == view.BankCardId);
var bankCard = new BankCard
{
Number = view.BankCardId,
Address = view.Address,
Name = view.Name,
Type = view.Type,
UserId = view.LoginUserId,
Id = view.Id.ToObjectId()
};
if (model == null)
{
var result = Add(bankCard);
if (!result)
{
return(ServiceResult.Failed);
}
return(ServiceResult.Success);
}
return(ServiceResult.Failure("该银行卡已经绑定"));
}
public Tuple <ServiceResult, AutoTable> Table(string type, object query, AutoBaseModel autoBaseModel)
{
Type typeFind = null;
object instanceFind = null;
var checkType = Resolve <IUIBaseService>().CheckType(type, ref typeFind, ref instanceFind);
if (!checkType.Succeeded)
{
return(new Tuple <ServiceResult, AutoTable>(checkType, new AutoTable()));
}
var autoTable = AutoTableMapping.Convert(typeFind.FullName);
#region IAutoTable类型
// 如果是IAutoTable类型，则数据从AutoTable中获取,否则从Api接口中获取
if (instanceFind is IAutoTable)
{
var target = new Interpreter().SetVariable("autoTable", instanceFind);
var parameters = new[]
{
new Parameter("query", query),
new Parameter("baseModel", autoBaseModel)
};
try {
autoTable.Result = target.Eval("autoTable.PageTable(query,baseModel)", parameters);
} catch (Exception ex) {
return(new Tuple <ServiceResult, AutoTable>(ServiceResult.Failure(ex.Message),
new AutoTable()));
}
}
#endregion IAutoTable类型
#region autoConfig类型
else if (instanceFind is IAutoConfig)
{
var data = Resolve <IAlaboAutoConfigService>().GetObjectList(typeFind);
var result = PagedList <object> .Create(data, data.Count, 100, 1);
var apiRusult = new PageResult <object> {
PageCount = result.PageCount,
Result = result,
RecordCount = result.RecordCount,
CurrentSize = result.CurrentSize,
PageIndex = result.PageIndex,
PageSize = result.PageSize
};
autoTable.Result = apiRusult;
}
else if (instanceFind is IEntity)
{
var serviceName = $"{typeFind.Name}Service";
var result = ServiceInterpreter.Eval <object>(serviceName, "GetApiPagedList", query, autoBaseModel);
autoTable.Result = result;
}
#endregion autoConfig类型
return(new Tuple <ServiceResult, AutoTable>(ServiceResult.Success, autoTable));
}
/// <summary>
/// 商品保存
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public ServiceResult EditProduct(ProductEditOuput parameter)
{
#region 基础数据赋值
var isAdmin = Resolve <IUserService>().IsAdmin(parameter.UserId);
parameter.Product.CategoryId = parameter.Category.Id;
//if (parameter.Product.Id == 0) parameter.Product.StoreId = parameter.Store.Id;
parameter.ProductDetail.ProductId = parameter.Product.Id;
#endregion 基础数据赋值
#region 基础安全验证
if (parameter.PriceStyleConfig == null)
{
return(ServiceResult.Failure("商城模式不能为空"));
}
if (parameter.ProductSkus == null || parameter.ProductSkus.Count == 0)
{
return(ServiceResult.Failure("商品Sku不能为空"));
}
if (parameter.Store == null)
{
return(ServiceResult.Failure("店铺不能为空"));
}
if (!isAdmin)
{
if (parameter.Store.UserId != parameter.UserId)
{
return(ServiceResult.Failure("您无权编辑其他店铺商品"));
}
}
//if (parameter.Product.PurchasePrice > parameter.Product.CostPrice) {
// return ServiceResult.Failure("进货价不能大于成本价");
//}
//尝试过特性,属性set函数 均无效
if (parameter.Product.CostPrice > parameter.Product.Price)
{
return(ServiceResult.Failure("商品销售价必须为大于等于成本价"));
}
if (parameter.Product.CostPrice > parameter.Product.MarketPrice)
{
return(ServiceResult.Failure("商品市场价必须为大于等于成本价"));
}
//判断sku的价格是否低于成本
foreach (var item in parameter.ProductSkus)
{
if (item.CostPrice > item.Price)
{
return(ServiceResult.Failure("商品SKU销售价必须为大于等于成本价"));
}
if (item.CostPrice > item.MarketPrice)
{
return(ServiceResult.Failure("商品SKU市场价必须为大于等于成本价"));
}
if (item.FenRunPrice > item.CostPrice || item.FenRunPrice > item.MarketPrice ||
item.FenRunPrice > item.MarketPrice)
{
return(ServiceResult.Failure("分润价格不能大于其他价格"));
}
}
if (parameter.Product.StoreId.IsObjectIdNullOrEmpty())
{
return(ServiceResult.Failure("请为商品选择店铺"));
}
var category = Resolve <ICategoryService>().GetSingle(parameter.Product.CategoryId);
if (category == null)
{
return(ServiceResult.Failure("未选择商品类目，或者商品类目已不存在"));
}
if (Repository <IProductRepository>().Count(r => r.Bn == parameter.Product.Bn && r.Id != parameter.Product.Id) >
0)
{
return(ServiceResult.Failure("该货号已存在，请使用其他货号"));
}
#endregion 基础安全验证
#region 商品图片处理
parameter.ProductDetail.ImageJson =
Resolve <IProductApiService>().CreateImage(parameter.Product, parameter.Images);
#endregion 商品图片处理
#region 核心数据赋值
if (parameter.Product.PriceStyleId.IsGuidNullOrEmpty())
{
// 商城模式
parameter.Product.PriceStyleId = parameter.PriceStyleConfig.Id;
}
parameter.Product.DisplayPrice = Resolve <IProductService>().GetDisplayPrice(parameter.Product.Price,
parameter.Product.PriceStyleId, parameter.Product.MinCashRate);
parameter.ProductDetail.PropertyJson = ObjectExtension.ToJson(parameter.Category);
//如果是管理员就直接上架或者下架
if (isAdmin)
{
if (parameter.OnSale)
{
parameter.Product.ProductStatus = GoodsStatus.Online;
}
else
{
parameter.Product.ProductStatus = GoodsStatus.SoldOut;
}
}
else
{
//如果是供应商直接状态为审核状态
parameter.Product.ProductStatus = GoodsStatus.Auditing;
}
parameter.Product.ModifiedTime = DateTime.Now;
#endregion 核心数据赋值
#region 数据保存
var context = Repository <IProductRepository>().RepositoryContext;
context.BeginTransaction();
try {
parameter.ProductDetail.Extension = ObjectExtension.ToJson(parameter.ProductDetail.ProductDetailExtension);
if (parameter.Product.Id == 0)
{
Resolve <IProductService>().Add(parameter.Product); // 添加Shop_product 表
parameter.ProductDetail.ProductId = parameter.Product.Id;
Resolve <IProductDetailService>().Add(parameter.ProductDetail); // 添加Shop_productdetai表
}
else
{
Resolve <IProductService>().Update(parameter.Product); // 更新Shop_product 表
Resolve <IProductDetailService>().UpdateNoTracking(parameter.ProductDetail); // 更新Shop_productdetai表
}
// 更新商品Sku
var skuResult = Resolve <IProductSkuService>()
.AddUpdateOrDelete(parameter.Product, parameter.ProductSkus); // 更新Shop_productsku表
if (!skuResult.Succeeded)
{
throw new ValidException(skuResult.ToString());
}
//添加商品分类和标签
Resolve <IRelationIndexService>().AddUpdateOrDelete <ProductClassRelation>(parameter.Product.Id,
string.Join(',', parameter.ProductDetail.ProductDetailExtension.StoreClass));
Resolve <IRelationIndexService>().AddUpdateOrDelete <ProductTagRelation>(parameter.Product.Id,
string.Join(',', parameter.ProductDetail.ProductDetailExtension.Tags));
context.SaveChanges();
context.CommitTransaction();
} catch (Exception ex) {
context.RollbackTransaction();
return(ServiceResult.Failure("更新失败:" + ex.Message));
} finally {
context.DisposeTransaction();
}
#endregion 数据保存
#region 保存后操作
//删除缓存
var cacheKey = "ApiProduct_" + parameter.Product.Id;
ObjectCache.Remove(cacheKey);
// 更新商品Sku价格
//Resolve<IProductSkuService>().AutoUpdateSkuPrice(parameter.Product.Id);
Resolve <IProductService>().Log($"成功添加一件商品,商品货号：{parameter.Product.Bn}");
// 更新商品数据到数据中台
var result = Resolve <IProductGoodsService>().AddOrUpdateGoods(parameter.Product.Id);
return(result);
#endregion 保存后操作
}
/// <summary>
/// 添加或更新地址
/// </summary>
/// <param name="userAddress"></param>
public ServiceResult AddOrUpdateSingle(UserAddress userAddress)
{
if (userAddress == null)
{
throw new ValidException("地址不能为空");
}
var find = GetSingle(userAddress.Id);
if (userAddress.Type == AddressLockType.UserInfoAddress)
{
find = GetSingle(u => u.UserId == userAddress.UserId && u.Type == userAddress.Type);
}
if (find == null)
{
find = new UserAddress();
}
var user = Resolve <IAlaboUserService>().GetSingle(r => r.Id == userAddress.UserId);
if (user == null)
{
return(ServiceResult.Failure("会员不存在"));
}
var region = Resolve <IRegionService>().GetSingle(r => r.RegionId == userAddress.RegionId);
if (region == null)
{
return(ServiceResult.Failure("您选择的区域不存在"));
}
if (region.Level != RegionLevel.County)
{
return(ServiceResult.Failure("请选择完整的地址"));
}
find.AddressDescription = region.FullName + " " + userAddress.Address;
find.Address = userAddress.Address;
find.Type = userAddress.Type;
find.City = region.CityId;
find.Province = region.ProvinceId;
find.IsDefault = userAddress.IsDefault;
find.ZipCode = userAddress.ZipCode;
find.UserId = user.Id;
find.RegionId = region.RegionId;
find.Mobile = userAddress.Mobile;
find.Name = userAddress.Name;
//名字和手机特殊处理
if (find.Mobile.IsNullOrEmpty())
{
find.Mobile = user.Mobile;
}
if (find.Name.IsNullOrEmpty())
{
find.Name = user.Name;
}
if (find.Name.IsNullOrEmpty())
{
find.Name = user.UserName;
}
var saveResult = AddOrUpdate(find, r => r.Id == find.Id);
if (saveResult && userAddress.IsDefault)
{
return(SetDefault(userAddress.UserId, find.Id)); // 如果设置为默认值地址，则更新为默认值地址
}
if (saveResult && !userAddress.IsDefault)
{
return(ServiceResult.Success);
}
return(ServiceResult.Failure("地址保存失败"));
}
/// <summary>
/// 保存收货地址
/// </summary>
/// <param name="addressInput"></param>
public ServiceResult SaveOrderAddress(AddressInput addressInput)
{
#region MyRegion
//if (addressInput == null) {
// throw new System.Exception("输入不能为空");
//}
//var userAddress = AutoMapping.SetValue<UserAddress>(addressInput);
//if (!addressInput.Id.IsNullOrEmpty()) {
// userAddress.Id = addressInput.Id.ToObjectId();
//} else {
// var addressList = Resolve<IUserAddressService>().GetList(u => u.UserId == addressInput.UserId);
// if (addressList.Count >= 1) {
// return ServiceResult.Failure("每个用户只允许拥有一个收货地址");
// }
//}
//userAddress.Type = AddressLockType.OrderAddress;
//return AddOrUpdateSingle(userAddress);
#endregion MyRegion
#region 5.20后开放
//不允许更改收货地址
//只允许更改收货人姓名及电话
//限定每个用户只能有一个地址
if (addressInput == null)
{
throw new ValidException("输入不能为空");
}
var userAddress = AutoMapping.SetValue <UserAddress>(addressInput);
var addressConfig = Resolve <IAutoConfigService>().GetValue <UserAddressConfig>();
if (!addressInput.Id.IsNullOrEmpty() && !addressInput.Id.ToObjectId().IsObjectIdNullOrEmpty())
{
//修改
userAddress.Id = addressInput.Id.ToObjectId();
var model = Resolve <IUserAddressService>().GetSingle(u => u.Id == addressInput.Id.ToObjectId());
if (model == null)
{
return(ServiceResult.Failure("数据异常"));
}
//查看配置是否开启
if (addressConfig.IsEnble)
{
if (userAddress.Address != model.Address) //不允许修改
{
return(ServiceResult.Failure(addressConfig.EditTips));
}
if (userAddress.RegionId != model.RegionId) //不允许修改
{
return(ServiceResult.Failure(addressConfig.EditTips));
}
}
}
else
{
//限定每个用户只能有一个地址
//var addressList = Resolve<IUserAddressService>().GetList(u => u.UserId == addressInput.UserId);
//if (addressList.Count >= 1)
//{
// return ServiceResult.Failure("每个用户只允许拥有一个收货地址");
//}
//新增
if (addressConfig.IsEnble)
{
var addressList = Resolve <IUserAddressService>().GetList(u => u.UserId == addressInput.UserId);
if (addressList.Count >= addressConfig.MaxNumber)
{
return(ServiceResult.Failure(addressConfig.AddTips));
}
}
}
userAddress.Id = addressInput.Id.ToObjectId();
userAddress.Type = AddressLockType.OrderAddress;
return(AddOrUpdateSingle(userAddress));
#endregion 5.20后开放
}
/// <summary>
/// 保存
/// </summary>
/// <param name="model"></param>
/// <param name="autoModel"></param>
/// <returns></returns>
public ServiceResult Save(object model, AutoBaseModel autoModel)
{
if (model == null)
{
return(ServiceResult.Failure("保存的内容不能为空"));
}
var aform = model.MapTo <ArticleAutoForm>();
var input = model.MapTo <Article>();
if (aform.Classes != null)
{
input.Classes = aform.Classes.Join();
}
if (aform.Tags != null)
{
input.Tags = aform.Tags.Join();
}
input.ChannelId = aform.ChannelId.ToObjectId();
var article = AutoMapping.SetValue <Article>(input);
var channel = Resolve <IChannelService>().GetSingle(r => r.Id == article.ChannelId);
if (channel == null)
{
Tuple.Create(ServiceResult.Failure("频道不存在"), new Article());
}
var SerResult = ServiceResult.Success;
article.RelationId = GetMaxRelationId();
article.Id = aform.Id.ToObjectId();
article.Tags = input.Tags;
var entity = Resolve <IArticleAdminService>().GetSingle(article.Id);
var result = false;
if (entity == null)
{
result = Resolve <IArticleAdminService>().Add(article);
if (result)
{
SerResult = ServiceResult.Success;
}
else
{
SerResult = ServiceResult.Failed;
}
}
else
{
result = Resolve <IArticleAdminService>().Update(article);
}
if (result)
{
if (!string.IsNullOrEmpty(input.Classes))
{
// 添加标签和分类
var classType = Resolve <IChannelService>().GetChannelClassType(channel);
var classIds = input.Classes;
Resolve <IRelationIndexService>()
.AddUpdateOrDelete(classType.FullName, article.RelationId, classIds);
}
if (!string.IsNullOrEmpty(input.Tags))
{
var tagType = Resolve <IChannelService>().GetChannelTagType(channel);
var tagIds = input.Tags;
Resolve <IRelationIndexService>()
.AddUpdateOrDelete(tagType.FullName, article.RelationId, tagIds);
}
DeleteCache();
SerResult = ServiceResult.Success;
}
else
{
SerResult = ServiceResult.Failed;
}
return(SerResult);
}
public async Task <ServiceResult <PaymentCardResponse> > ProcessCardPaymentAsync(PaymentCardRequest request, int userId, OrderPlace orderPlace)
{
var authServiceResult = await _paymentAuthorizeService.GetAuthorizeTokenAsync();
if (authServiceResult.IsValid)
{
using (var client = new HttpClient(new HttpClientHandler
{
AllowAutoRedirect = false
}))
{
client.BaseAddress = new Uri(_paymentSettings.HostAddress);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer",
authServiceResult.Result.access_token);
var orderPaymentInfo = await PrepareCompleteCardPayuRequestAsync(request);
var requestBody = JsonConvert.SerializeObject(request);
//var response = await client.PostAsync(_paymentSettings.OrderCreateEndpoint,
// new StringContent(requestBody, Encoding.UTF8, "application/json"));
//if (response.IsSuccessStatusCode || response.StatusCode == HttpStatusCode.Found)
//{
// var responseObj = JsonConvert.DeserializeObject<PaymentCardResponse>(await response.Content.ReadAsStringAsync());
// await CreateNewOrderAsync(request, userId, orderPlace, orderPaymentInfo);
// if (responseObj.status.statusCode == "SUCCESS")
// {
// return ServiceResult<PaymentCardResponse>.Success(responseObj);
// }
//}
//return ServiceResult<PaymentCardResponse>.Failure(response.ReasonPhrase);
//TODO:Uncomment above code when payu express integrtation will work
await CreateNewOrderAsync(request, userId, orderPlace, orderPaymentInfo);
return(ServiceResult <PaymentCardResponse> .Success(new PaymentCardResponse
{
status = new CardStatus
{
statusCode = new Random().Next(0, 2) >= 1 ? "SUCCESS" : "ERROR",
statusDesc = "Request successful"
},
orderId = Guid.NewGuid().ToString(),
payMethods = new CardPayMethods
{
payMethod = new CardPayMethod
{
value = request.payMethods.payMethod.value,
card = new Card
{
expirationMonth = "12",
expirationYear = "2018",
number = "12345*****2314"
}
}
}
}));
}
}
return(ServiceResult <PaymentCardResponse> .Failure(authServiceResult.ValidationErrors));
}
