public override async Task<CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map<Coupon>(request.Coupon);
await _discountRepository.CreateDiscount(coupon);
_logger.LogInformation("Discount is successfully created. ProductName : {ProductName}", coupon.ProductName);
var couponModel = _mapper.Map<CouponModel>(coupon);
return couponModel;
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
await _repo.CreateDiscount(coupon);
_logger.LogInformation($"Discount has been created. ProductName : {coupon.ProductName}");
return(_mapper.Map <CouponModel>(coupon));
}
public async Task <Discount> CreateDiscountAsync(CreateDiscountRequest createDiscountRequest)
{
ValidateModel(createDiscountRequest);
var response = await PostAsJsonAsync("/discounts", JsonConvert.SerializeObject(createDiscountRequest)).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <DiscountResponse>(
await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Discount);
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
await _repository.CreateDiscount(coupon);
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
await _repository.CreateDiscount(coupon).ConfigureAwait(false);
_logger.LogInformation($"Discount is succesfully created. ProductName: {coupon.ProductName}");
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public override async Task <CreateDiscountResponse> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
_logger.LogInformation($"Received: {context}");
var success = await _discountRepository.CreateVoucher(
_mapper.Map <Voucher>(request.VoucherToCreate)
);
return(new CreateDiscountResponse {
Success = success
});
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
Coupon coupon = GetCoupon(request.Coupon);
await _discountRepository.CreateDiscount(coupon);
CouponModel couponModel = GetCouponModel(coupon);
_logger.LogInformation("Discount is successfully created. ProductName : {productName}", coupon.ProductName);
return(couponModel);
}
public async Task <IActionResult> AddDiscount([FromRoute] int agencyId, [FromBody] CreateDiscountRequest createDiscountRequest)
{
var(_, isFailure, error) = await _discountManagementService.Add(agencyId, createDiscountRequest);
if (isFailure)
{
return(BadRequest(ProblemDetailsBuilder.Build(error)));
}
return(NoContent());
}
internal static CreateDiscountRequest BuildCreateDiscountRequest()
{
var request = new CreateDiscountRequest()
{
Value = 100,
Cycles = 1,
DiscountType = "flat"
};
return(request);
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
await _repository.CreateDiscount(coupon);
Log.Fatal("Discount is successfully created. ProductName : {ProductName}", coupon.ProductName);
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = this.mapper.Map <Coupon>(request.Coupon);
var result = await this.discountRepository.CreateDiscount(coupon);
if (!result)
{
throw new RpcException(new Status(StatusCode.NotFound, $""));
}
return(this.mapper.Map <CouponModel>(coupon));
}
internal static CreateDiscountRequest BuildCreateDiscountOnItemRequest(string subscriptionItemId)
{
var request = new CreateDiscountRequest()
{
Value = 100,
Cycles = 1,
DiscountType = "percentage",
ItemId = subscriptionItemId
};
return(request);
}
public override async Task <CouponDTO> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var insertedId = await _discountRepository.CreateCoupon(_mapper.Map <Coupon>(request.Coupon));
var newCoupon = await _discountRepository.GetCoupon(insertedId);
if (newCoupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Coupon not found"));
}
return(_mapper.Map <CouponDTO>(newCoupon));
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request);
if (!await _discountRepository.CreateDiscount(coupon))
{
throw new RpcException(new Status(StatusCode.AlreadyExists, "Coupon already exists"));
}
_logger.LogInformation("Discount is successfully created. ProductName : {ProductName}", coupon.ProductName);
return(_mapper.Map <CouponModel>(coupon));
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
_repository.CreateCoupon(coupon);
await _repository.SaveChangesAsync();
_logger.LogInformation("Coupon is successfully created. CategoryName : {CategoryName}", coupon.CategoryName);
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public async Task <CouponModel> CreateDiscount(CouponModel coupon)
{
var discount = new CouponModel()
{
ProductName = coupon.ProductName, Amount = coupon.Amount, Description = coupon.Description
};
var createDiscountRequest = new CreateDiscountRequest()
{
Coupon = discount
};
var res = await discountProtoServiceClient.CreateDiscountAsync(createDiscountRequest);
return(res);
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
bool status = await _repository.CreateDiscount(coupon);
if (status)
{
_logger.LogInformation("Discount is successfully created. ProductName : {ProductName}", coupon.ProductName);
}
else
{
_logger.LogInformation("Discount creation failed. ProductName : {ProductName}", coupon.ProductName);
}
var couponModel = _mapper.Map <CouponModel>(coupon);
couponModel.Status = status;
return(couponModel);
}
public override async Task <CouponModel> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Model);
try
{
await _repository.CreateDiscount(coupon);
}
catch (Exception ex)
{
throw new Exception($"Failed to create coupon", ex);
}
_logger.LogInformation($"Successfully created {request.Model}");
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public override async Task <CouponResponse> CreateDiscount(CreateDiscountRequest request, ServerCallContext context)
{
var coupon = _mapper.Map <Coupon>(request.Coupon);
bool created = await _discountRepository.CreateDiscount(coupon);
if (!created)
{
_logger.LogError(new RpcException(new Status(StatusCode.InvalidArgument,
$"Error creating discount for {request.Coupon.ProductId}")),
$"Discount with ProductId={request.Coupon.ProductId} has not been created.");
return(null);
}
_logger.LogInformation($"Discount successfully created for ProductId: " +
$"{coupon.ProductId} - Amount: {coupon.Amount} - Description: {coupon.Description}");
var couponResponse = _mapper.Map <CouponResponse>(coupon);
return(couponResponse);
}
public CreateDiscountResponse PostCreateDiscount(CreateDiscountRequest _request)
{
String urlorg = ConfigurationManager.AppSettings["CRMUrlOrg"].ToString();
String organization = ConfigurationManager.AppSettings["CRMOrganization"].ToString();
String domain = ConfigurationManager.AppSettings["CRMDomain"].ToString();
String username = ConfigurationManager.AppSettings["CRMUsername"].ToString();
String password = ConfigurationManager.AppSettings["CRMPassword"].ToString();
String hostimage = ConfigurationManager.AppSettings["HostImage"].ToString();
String hostimage2 = ConfigurationManager.AppSettings["HostImage2"].ToString();
String curfileimage = ConfigurationManager.AppSettings["CurfileImage"].ToString();
CRMLibs crmlibs = new CRMLibs(urlorg, organization, domain, username, password);
CreateDiscountResponse response = new CreateDiscountResponse();
try
{
Entity discount = new Entity("xrm_discounts");
if (_request.DiscountName != null)
{
discount.Attributes["xrm_name"] = _request.DiscountName;
}
if (_request.StartDate != null)
{
discount.Attributes["xrm_startdate"] = _request.StartDate;
}
if (_request.EndDate != null)
{
discount.Attributes["xrm_enddate"] = _request.EndDate;
}
if (_request.Description != null)
{
discount.Attributes["xrm_description"] = _request.Description;
}
if (_request.StoreCategory != null)
{
discount.Attributes["xrm_storecategory"] = new EntityReference("xrm_storecategory", new Guid(_request.StoreCategory));
}
if (_request.Mall != null)
{
discount.Attributes["xrm_mall"] = new EntityReference("xrm_mall", new Guid(_request.Mall));
}
if (_request.Tag != null)
{
discount.Attributes["xrm_tag"] = _request.Tag;
}
if (_request.Tenant != null)
{
discount.Attributes["xrm_tenant"] = new EntityReference("xrm_tenant", new Guid(_request.Tenant));
}
Guid DiscountID = crmlibs.createentity(discount);
Entity discountupdate = new Entity("xrm_discounts", DiscountID);
if (_request.ImageBase64 != null && _request.ImageType != null)
{
string path = Directory.GetCurrentDirectory();
string target = hostimage + @"Discount\Full\";
if (!Directory.Exists(target))
{
Directory.CreateDirectory(target);
}
Environment.CurrentDirectory = (target);
string target2 = hostimage2 + @"Discount\Full\";
if (!Directory.Exists(target2))
{
Directory.CreateDirectory(target2);
}
Environment.CurrentDirectory = (target2);
string imageName = DiscountID.ToString() + "-Full-" + DateTime.Now.ToString("yyyyMMdd") + "." + _request.ImageType;
string imgPath = Path.Combine(target, imageName);
string imgPath2 = Path.Combine(target2, imageName);
byte[] imageBytes = Convert.FromBase64String(_request.ImageBase64);
string curFile = curfileimage + @"Discount\Full\" + imageName;
File.WriteAllBytes(imgPath, imageBytes);
File.WriteAllBytes(imgPath2, imageBytes);
discountupdate.Attributes["xrm_imageurl"] = curFile;
}
crmlibs.updateentity(discountupdate);
response.DiscountID = DiscountID.ToString();
response.Code = "0";
response.Message = "Success";
}
catch (Exception ex)
{
response.Code = "1";
response.Message = ex.Message;
}
return(response);
}
public BaseResponse <GetDiscountResponse> CreateDiscount(string subscriptionId, CreateDiscountRequest request)
{
var method = HttpMethod.Post;
var endpoint = $"/subscriptions/{subscriptionId}/discounts";
return(this.HttpClientUtil.SendRequest <GetDiscountResponse>(method, endpoint, request));
}
public DiscountCreateEventData(int agencyId, CreateDiscountRequest createDiscountRequest)
{
AgencyId = agencyId;
CreateDiscountRequest = createDiscountRequest;
}
public Task <Result> Add(int agencyId, CreateDiscountRequest createDiscountRequest)
{
return(ValidatePercent(createDiscountRequest.DiscountPercent)
.Bind(ValidateTargetMarkup)
.Bind(ValidateAgency)
.Bind(DiscountsDontExceedMarkups)
.BindWithTransaction(_context, () => Result.Success()
.Tap(UpdateDiscount)
.Bind(WriteAuditLog)));
async Task <Result> ValidateTargetMarkup()
{
var targetMarkup = await _context.MarkupPolicies
.SingleOrDefaultAsync(p => p.Id == createDiscountRequest.TargetMarkupId);
if (targetMarkup is null)
{
return(Result.Failure($"Could not find markup policy with id {createDiscountRequest.TargetMarkupId}"));
}
return(targetMarkup.SubjectScopeType == SubjectMarkupScopeTypes.Global
? Result.Success()
: Result.Failure("Cannot apply discount to non-global markup policy"));
}
async Task <Result> ValidateAgency()
=> await _context.Agencies.AnyAsync(a => a.Id == agencyId)
? Result.Success()
: Result.Failure($"Could not find an agency with id {agencyId}");
async Task <Result> DiscountsDontExceedMarkups()
{
var markupPolicy = await _context.MarkupPolicies.SingleOrDefaultAsync(x => x.Id == createDiscountRequest.TargetMarkupId);
var markupFunction = _templateService.CreateFunction(markupPolicy.TemplateId, markupPolicy.TemplateSettings);
var allDiscounts = await _context.Discounts
.Where(x => x.TargetPolicyId == markupPolicy.Id)
.Where(d => d.TargetAgencyId == agencyId)
.Where(d => d.IsActive)
.Select(d => d.DiscountPercent)
.ToListAsync();
allDiscounts.Add(createDiscountRequest.DiscountPercent);
return(DiscountsValidator.DiscountsDontExceedMarkups(allDiscounts, markupFunction));
}
Task UpdateDiscount()
{
var now = _dateTimeProvider.UtcNow();
_context.Discounts.Add(new Discount
{
DiscountPercent = createDiscountRequest.DiscountPercent,
Description = createDiscountRequest.Description,
TargetPolicyId = createDiscountRequest.TargetMarkupId,
IsActive = true,
TargetAgencyId = agencyId,
Created = now,
Modified = now
});
return(_context.SaveChangesAsync());
}
Task <Result> WriteAuditLog()
=> _managementAuditService.Write(ManagementEventType.DiscountCreate, new DiscountCreateEventData(agencyId, createDiscountRequest));
}
