public async Task <IActionResult> PutGiftCertificate([FromRoute] int id, [FromBody] GiftCertificate giftCertificate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != giftCertificate.Id)
{
return(BadRequest());
}
_context.Entry(giftCertificate).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GiftCertificateExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
protected void GiftCertificatesGrid_RowCommand(object sender, GridViewCommandEventArgs e)
{
int GiftCertificateId = AlwaysConvert.ToInt(e.CommandArgument);
GiftCertificate gc = GiftCertificateDataSource.Load(GiftCertificateId);
if (gc == null)
{
return;
}
IGiftCertKeyProvider provider = AbleContext.Container.Resolve <IGiftCertKeyProvider>();
if (e.CommandName.Equals("Generate"))
{
gc.SerialNumber = provider.GenerateGiftCertificateKey();
gc.AddActivatedTransaction();
gc.Save();
GiftCertificatesGrid.DataBind();
}
else if (e.CommandName.Equals("Deactivate"))
{
gc.SerialNumber = "";
gc.AddDeactivatedTransaction();
gc.Save();
GiftCertificatesGrid.DataBind();
}
}
private string GetValue(string key, GiftCertificate certificate)
{
if (!string.IsNullOrEmpty(key) && certificate != null)
{
switch (key.ToUpper())
{
case CertificateFields.DONOR:
return(certificate.Donor.Name);
case CertificateFields.ETA:
return(certificate.ETA.ToShortDateString());
case CertificateFields.GIFTDATE:
return(certificate.GiftDate.ToShortDateString());
case CertificateFields.REFERENCENO:
return(certificate.ReferenceNo);
case CertificateFields.SINUMBER:
return(certificate.ShippingInstruction.Value);
case CertificateFields.VESSEL:
return(certificate.Vessel);
}
}
return(string.Empty);
}
public ActionResult Edit(GiftCertificateViewModel giftcertificate)
{
//just incase the user meses with the the hidden GiftCertificateID field
GiftCertificate giftcert = _giftCertificateService.FindById(giftcertificate.GiftCertificateID);
if (ModelState.IsValid && giftcert != null)
{
GiftCertificate giftCertificateModel = giftcertificate.GenerateGiftCertificate();
List <Cats.Models.Hubs.GiftCertificateDetailsViewModel> insertCommodities = GetSelectedGiftCertificateDetails(giftcertificate.JSONInsertedGiftCertificateDetails);
List <Cats.Models.Hubs.GiftCertificateDetailsViewModel> deletedCommodities = GetSelectedGiftCertificateDetails(giftcertificate.JSONDeletedGiftCertificateDetails);
List <Cats.Models.Hubs.GiftCertificateDetailsViewModel> updateCommodities = GetSelectedGiftCertificateDetails(giftcertificate.JSONUpdatedGiftCertificateDetails);
_giftCertificateService.Update(giftCertificateModel, GenerateGiftCertificate(insertCommodities),
GenerateGiftCertificate(updateCommodities),
GenerateGiftCertificate(deletedCommodities));
return(RedirectToAction("Index"));
}
ViewBag.Commodities = _commodityService.GetAllCommodity().OrderBy(o => o.Name);
ViewBag.DCurrencies = _detailService.GetAllDetail().Where(d => d.MasterID == Master.Constants.CURRENCY).OrderBy(o => o.SortOrder);
ViewBag.DFundSources = _detailService.GetAllDetail().Where(d => d.MasterID == Master.Constants.FUND_SOURCE).OrderBy(o => o.SortOrder);
ViewBag.DBudgetTypes = _detailService.GetAllDetail().Where(d => d.MasterID == Master.Constants.BUDGET_TYPE).OrderBy(o => o.SortOrder);
ViewBag.CommodityTypes = new SelectList(_commodityTypeService.GetAllCommodityType().OrderBy(o => o.Name), "CommodityTypeID", "Name", giftcert.GiftCertificateDetails.FirstOrDefault().Commodity.CommodityTypeID);
ViewBag.Donors = new SelectList(_donorService.GetAllDonor().OrderBy(o => o.Name), "DonorID", "Name", giftcertificate.DonorID);
ViewBag.Programs = new SelectList(_programService.GetAllProgram(), "ProgramID", "Name", giftcertificate.ProgramID);
ViewBag.DModeOfTransports = new SelectList(_detailService.GetAllDetail().Where(d => d.MasterID == Master.Constants.TRANSPORT_MODE).OrderBy(o => o.SortOrder), "DetailID", "Name", giftcertificate.DModeOfTransport);
return(View(giftcertificate));
}
public bool DeleteGiftCertificate(GiftCertificate giftCertificate)
{
if (giftCertificate == null) return false;
_unitOfWork.GiftCertificateRepository.Delete(giftCertificate);
_unitOfWork.Save();
return true;
}
protected void Page_Load(object sender, EventArgs e)
{
_OrderId = AbleCommerce.Code.PageHelper.GetOrderId();
_GiftCertificateId = AlwaysConvert.ToInt(Request.QueryString["GiftCertificateId"]);
_GiftCertificate = GiftCertificateDataSource.Load(_GiftCertificateId);
if (_GiftCertificate == null)
{
RedirectBack();
}
if (!Page.IsPostBack)
{
SerialNumber.Text = _GiftCertificate.SerialNumber;
Name.Text = _GiftCertificate.Name;
Balance.Text = string.Format("{0:F2}", _GiftCertificate.Balance);
ExpireDate.NullableSelectedDate = _GiftCertificate.ExpirationDate;
if (!string.IsNullOrEmpty(_GiftCertificate.SerialNumber))
{
ReGenerateSerialNumberLbl.Visible = true;
GenerateSerialNumberLbl.Visible = false;
}
else
{
ReGenerateSerialNumberLbl.Visible = false;
GenerateSerialNumberLbl.Visible = true;
}
}
}
private void PopulateControls()
{
GiftCertificate giftCertificate = DataAccessContext.GiftCertificateRepository.GetOne(GiftCertificateCode);
Order orders = DataAccessContext.OrderRepository.GetOne(
DataAccessContext.OrderItemRepository.GetOne(giftCertificate.OrderItemID).OrderID);
string fromuser = orders.Billing.FirstName + " " + orders.Billing.LastName;
string amount = StoreContext.Currency.FormatPrice(giftCertificate.GiftValue);
string expireDate;
if (giftCertificate.IsExpirable)
{
expireDate = String.Format("{0:dd} {0:MMM} {0:yyyy}", giftCertificate.ExpireDate);
}
else
{
expireDate = "-";
}
string subjectMail;
string bodyMail;
EmailTemplateTextVariable.ReplaceGiftCertificateLayoutText(
giftCertificate, orders, fromuser, amount, expireDate, out subjectMail, out bodyMail);
uxGiftLiteral.Text = bodyMail;
}
protected void Page_Load(object sender, EventArgs e)
{
GiftCertificate objgft = new GiftCertificate();
string message = "initialised";
try{
string couponcode = Request.QueryString["couponcode"];
string action = Request.QueryString["action"];
switch (action)
{
case ("checks"):
message = objgft.Giftcodecheck(couponcode);
break;
case ("usecoupon"):
int cartid = int.Parse(Request.QueryString["cartid"]);
message = objgft.UseGiftcode(couponcode, cartid);
break;
default:
message = "There is no such actions";
break;
}
}
catch(Exception couponex)
{
message = couponex.Message;
}
Response.Write(message);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,GctypeId,Value,IssuanceDate,DtipermitNo,ExpirationDate,LastModifiedBy,CreatedDate,ModifiedDate,Qrcode")] GiftCertificate giftCertificate)
{
if (id != giftCertificate.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(giftCertificate);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GiftCertificateExists(giftCertificate.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GctypeId"] = new SelectList(_context.Gctype, "Id", "Id", giftCertificate.GctypeId);
return(View(giftCertificate));
}
public void GetByIdReturnsGiftCertificateForKnownId()
{
GiftCertificate giftCertificate = _repository.GetById(KNOWN_GIFT_CERTIFICATE_ID);
Assert.IsNotNull(giftCertificate, "GetById returned null GiftCertificate.");
Assert.IsInstanceOf <GiftCertificate>(giftCertificate, "GetById returned the wrong type of object.");
}
protected void Page_Init(object sender, EventArgs e)
{
_GiftCertificateId = AlwaysConvert.ToInt(Request.QueryString["GiftCertificateId"]);
_GiftCertificate = GiftCertificateDataSource.Load(_GiftCertificateId);
if (_GiftCertificate == null)
{
Response.Redirect("MyAccount.aspx");
}
if ((_GiftCertificate.OrderItem.Order.UserId != AbleContext.Current.UserId) && (!AbleContext.Current.User.IsInRole("Admin")))
{
Response.Redirect("MyAccount.aspx");
}
if (!Page.IsPostBack)
{
//UPDATE CAPTION
if (_GiftCertificate.SerialNumber == null || _GiftCertificate.SerialNumber.Length == 0)
{
Caption.Text = "Not Assigned. Gift Certificate is not validated yet.";
}
else
{
Caption.Text = String.Format(Caption.Text, _GiftCertificate.Name, _GiftCertificate.OrderItem.Order.OrderNumber);
}
BindGiftCertificate();
}
}
/// <summary>
/// Processes a gift certificate validation event
/// </summary>
/// <param name="gc">Gift certificate that has been validated</param>
/// <param name="trans">GiftCertificateTransaction</param>
public static void GiftCertificateValidated(GiftCertificate gc, GiftCertificateTransaction trans)
{
Hashtable parameters = new Hashtable();
parameters["order"] = gc.OrderItem.Order;
parameters["customer"] = gc.OrderItem.Order.User;
parameters["giftcertificate"] = gc;
ProcessEmails(StoreEvent.GiftCertificateValidated, parameters);
}
private string PopulateCertificate(string templateString, GiftCertificate cert)
{
templateString = SearchAndReplace(CertificateFields.DONOR, GetValue(CertificateFields.DONOR, cert), templateString);
templateString = SearchAndReplace(CertificateFields.ETA, GetValue(CertificateFields.ETA, cert), templateString);
templateString = SearchAndReplace(CertificateFields.GIFTDATE, GetValue(CertificateFields.GIFTDATE, cert), templateString);
templateString = SearchAndReplace(CertificateFields.REFERENCENO, GetValue(CertificateFields.REFERENCENO, cert), templateString);
templateString = SearchAndReplace(CertificateFields.SINUMBER, GetValue(CertificateFields.SINUMBER, cert), templateString);
templateString = SearchAndReplace(CertificateFields.VESSEL, GetValue(CertificateFields.VESSEL, cert), templateString);
return(templateString);
}
protected String GetGCDescription(object dataItem)
{
GiftCertificate gc = (GiftCertificate)dataItem;
if (gc.Transactions.Count == 0)
{
return(String.Empty);
}
return(gc.Transactions[gc.Transactions.Count - 1].Description);
}
public bool DeleteGiftCertificate(GiftCertificate giftCertificate)
{
if (giftCertificate == null)
{
return(false);
}
_unitOfWork.GiftCertificateRepository.Delete(giftCertificate);
_unitOfWork.Save();
return(true);
}
public void GiftCertificateIsDeletedWhenDeleteCalled()
{
GiftCertificate persistedGiftCertificate = _repository.Save(_giftCertificate);
long certificateId = persistedGiftCertificate.Id;
_repository.Delete(persistedGiftCertificate);
_repository.GetById(certificateId);
}
private void SaveDataToSession()
{
var giftCertificateRepository = IoC.Resolve <IGiftCertificateRepository>();
if (GiftCertificate == null)
{
_giftCertificate = new GiftCertificate
{
Price = Amount.Value,
ToName = RecipientNameText.Text,
FromName = FromNameText.Text,
Message = MessageTextBox.Text,
ToEmail = RecipientEmailText.Text,
GiftCertificateTypeId =
!string.IsNullOrEmpty(GiftCertificateTypeCombo.SelectedValue)
? Convert.ToInt64(GiftCertificateTypeCombo.SelectedValue)
: 0
};
var claimCodeGenerator = new ClaimCodeGenerator();
var claimCode = claimCodeGenerator.GenerateClaimCode();
while (!giftCertificateRepository.IsClaimCodeValidForCertificate(claimCode, 0))
{
claimCode = claimCodeGenerator.GenerateClaimCode();
}
_giftCertificate.ClaimCode = claimCode;
}
else
{
_giftCertificate.Price = Amount.Value;
_giftCertificate.ToName = RecipientNameText.Text;
_giftCertificate.FromName = FromNameText.Text;
_giftCertificate.Message = MessageTextBox.Text;
_giftCertificate.ToEmail = RecipientEmailText.Text;
_giftCertificate.GiftCertificateTypeId =
!string.IsNullOrEmpty(GiftCertificateTypeCombo.SelectedValue)
? Convert.ToInt64(GiftCertificateTypeCombo.SelectedValue)
: 0;
}
var userSession = IoC.Resolve <ISessionContext>().UserSession;
var creatorOrganizationRoleUser =
IoC.Resolve <IOrgRoleUserModelBinder>().ToDomain(userSession.CurrentOrganizationRole,
userSession.UserId);
_giftCertificate.DataRecorderMetaData = new DataRecorderMetaData
{
DataRecorderCreator = creatorOrganizationRoleUser,
DateCreated = DateTime.Now
};
_giftCertificate = giftCertificateRepository.Save(_giftCertificate);
GiftCertificateId = _giftCertificate.Id;
}
/// <summary>
/// Submits an authorization request
/// </summary>
/// <param name="authorizeRequest">The authorization request</param>
/// <returns>Transaction that represents the result of the authorization request</returns>
public override Transaction DoAuthorize(AuthorizeTransactionRequest authorizeRequest)
{
Transaction transaction = new Transaction();
transaction.PaymentGatewayId = this.PaymentGatewayId;
//always use authorize capture.
transaction.TransactionType = TransactionType.AuthorizeCapture;
string serialNumber = authorizeRequest.Payment.AccountData;
GiftCertificate gc = GiftCertificateDataSource.LoadForSerialNumber(serialNumber);
string errorMessage = string.Empty;
if (gc == null)
{
errorMessage = "No gift certificate found with given serial number.";
}
else if (gc.IsExpired())
{
errorMessage = "Gift certificate is expired.";
}
else if (gc.Balance < authorizeRequest.Amount)
{
errorMessage = "Gift certificate does not have enough balance to complete this transaction.";
}
else
{
LSDecimal newAmount = gc.Balance - authorizeRequest.Amount;
gc.Balance = newAmount;
GiftCertificateTransaction trans = new GiftCertificateTransaction();
trans.TransactionDate = LocaleHelper.LocalNow;
trans.Amount = authorizeRequest.Amount;
trans.OrderId = authorizeRequest.Payment.OrderId;
trans.Description = string.Format("An amount of {0:lc} used in purchase. Remaining balance is {1:lc}.", authorizeRequest.Amount, newAmount);
gc.Transactions.Add(trans);
gc.Save();
}
if (string.IsNullOrEmpty(errorMessage))
{
transaction.TransactionStatus = TransactionStatus.Successful;
transaction.ResponseCode = "0";
transaction.ResponseMessage = "SUCCESS";
transaction.Amount = authorizeRequest.Amount;
}
else
{
transaction.TransactionStatus = TransactionStatus.Failed;
transaction.ResponseCode = "1";
transaction.ResponseMessage = errorMessage;
transaction.Amount = authorizeRequest.Amount;
}
return(transaction);
}
private void InsertGiftCertificate(GiftCertificateViewModel giftcertificate, GiftCertificate giftCertificateModel)
{
List <Models.GiftCertificateDetailsViewModel> giftCertificateDetails = GetSelectedGiftCertificateDetails(giftcertificate.JSONInsertedGiftCertificateDetails);
var giftDetails = GenerateGiftCertificate(giftCertificateDetails);
foreach (BLL.GiftCertificateDetail giftDetail in giftDetails)
{
giftCertificateModel.GiftCertificateDetails.Add(giftDetail);
}
_giftCertificateService.AddGiftCertificate(giftCertificateModel);
}
public async Task <IActionResult> Create([Bind("Id,GctypeId,Value,IssuanceDate,DtipermitNo,ExpirationDate,LastModifiedBy,CreatedDate,ModifiedDate,Qrcode")] GiftCertificate giftCertificate)
{
if (ModelState.IsValid)
{
_context.Add(giftCertificate);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["GctypeId"] = new SelectList(_context.Gctype, "Id", "Id", giftCertificate.GctypeId);
return(View(giftCertificate));
}
public async Task <IActionResult> PostGiftCertificate([FromBody] GiftCertificate giftCertificate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.GiftCertificate.Add(giftCertificate);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetGiftCertificate", new { id = giftCertificate.Id }, giftCertificate));
}
private bool AlreadyInUse(Basket basket, GiftCertificate gc)
{
foreach (BasketItem item in basket.Items)
{
if (item.OrderItemType == OrderItemType.GiftCertificatePayment &&
item.Sku == gc.SerialNumber)
{
return(true);
}
}
return(false);
}
public static string InsertCertificate(GiftCertificate GiftCertificate)
{
//send id=0 for all data
//var data = BAL.Select_Brands(0);
var data = Ddatatable.InsertCertificate(GiftCertificate);
HttpContext context = HttpContext.Current;
context.Response.Filter = new GZipStream(context.Response.Filter, CompressionMode.Compress);
HttpContext.Current.Response.AppendHeader("Content-Encoding", "gzip");
HttpContext.Current.Response.ContentType = "application/json charset=utf-8";
return(data);
}
/// <summary>
/// Updates the specified gift certificate model.
/// </summary>
/// <param name="giftCertificateModel">The gift certificate model.</param>
/// <param name="inserted">The inserted gift certificate detail.</param>
/// <param name="updated">The updated gift certificate detail.</param>
/// <param name="deleted">The deleted gift certificate detail.</param>
public void Update(GiftCertificate giftCertificateModel, List <GiftCertificateDetail> inserted,
List <GiftCertificateDetail> updated, List <GiftCertificateDetail> deleted)
{
// DRMFSSEntities1 db = new DRMFSSEntities1();
GiftCertificate orginal = _unitOfWork.GiftCertificateRepository.Get(p => p.GiftCertificateID == giftCertificateModel.GiftCertificateID).SingleOrDefault();
if (orginal != null)
{
orginal.GiftDate = giftCertificateModel.GiftDate;
orginal.DonorID = giftCertificateModel.DonorID;
orginal.ShippingInstructionID = giftCertificateModel.ShippingInstructionID;
orginal.ReferenceNo = giftCertificateModel.ReferenceNo;
orginal.Vessel = giftCertificateModel.Vessel;
orginal.ETA = giftCertificateModel.ETA;
orginal.ProgramID = giftCertificateModel.ProgramID;
orginal.PortName = giftCertificateModel.PortName;
orginal.DModeOfTransport = giftCertificateModel.DModeOfTransport;
foreach (GiftCertificateDetail insert in inserted)
{
orginal.GiftCertificateDetails.Add(insert);
}
foreach (GiftCertificateDetail delete in deleted)
{
GiftCertificateDetail deletedGiftDetails = _unitOfWork.GiftCertificateDetailRepository.FindBy(p => p.GiftCertificateDetailID == delete.GiftCertificateDetailID).SingleOrDefault();
if (deletedGiftDetails != null)
{
_unitOfWork.GiftCertificateDetailRepository.Delete(deletedGiftDetails);
}
}
foreach (GiftCertificateDetail update in updated)
{
GiftCertificateDetail updatedGiftDetails = _unitOfWork.GiftCertificateDetailRepository.Get(p => p.GiftCertificateDetailID == update.GiftCertificateDetailID).SingleOrDefault();
if (updatedGiftDetails != null)
{
updatedGiftDetails.CommodityID = update.CommodityID;
updatedGiftDetails.BillOfLoading = update.BillOfLoading;
updatedGiftDetails.YearPurchased = update.YearPurchased;
updatedGiftDetails.AccountNumber = update.AccountNumber;
updatedGiftDetails.WeightInMT = update.WeightInMT;
updatedGiftDetails.EstimatedPrice = update.EstimatedPrice;
updatedGiftDetails.EstimatedTax = update.EstimatedTax;
updatedGiftDetails.DCurrencyID = update.DCurrencyID;
updatedGiftDetails.DFundSourceID = update.DFundSourceID;
updatedGiftDetails.DBudgetTypeID = update.DBudgetTypeID;
updatedGiftDetails.ExpiryDate = update.ExpiryDate;
}
}
_unitOfWork.Save();
}
}
protected void CreateCertificate()
{
if (!DataValidation())
{
return;
}
MsgErr(true);
try
{
var curCurrency = CurrencyService.CurrentCurrency;
Certificate = new GiftCertificate
{
CertificateCode = lblCertificateCode.Text,
FromName = txtFromName.Text,
ToName = txtToName.Text,
Paid = chkPaid.Checked,
Used = chkUsed.Checked,
Enable = chkEnable.Checked,
Type = rbtnEmail.Checked ? CertificatePostType.Email : CertificatePostType.Mail,
Sum = Convert.ToDecimal(txtSum.Text),
CertificateMessage = txtMessage.Text,
CurrencyCode = curCurrency.Symbol,
CurrencyValue = curCurrency.Value,
FromEmail = txtFromEmail.Text
};
if (rbtnEmail.Checked)
{
Certificate.Email = txtEmail.Text;
}
else
{
Certificate.Country = cboCountry.SelectedItem.Text;
Certificate.Zone = MultiViewRegion.ActiveViewIndex == 0 ? cboRegion.SelectedItem.Text : txtState.Text;
Certificate.City = txtCity.Text;
Certificate.Zip = txtZip.Text;
Certificate.Address = txtAddress.Text;
}
if (Certificate.Paid && !CustomerSession.CurrentCustomer.IsVirtual)
{
GiftCertificateService.SendCertificateMails(Certificate);
}
GiftCertificateService.AddCertificate(Certificate);
}
catch (Exception ex)
{
MsgErr(ex.Message + " Create Certificate error");
Debug.LogError(ex);
}
}
private bool IsExistGiftCertificate()
{
GiftCertificate giftCertificate = DataAccessContext.GiftCertificateRepository.GetOne(uxCouponIDText.Text.Trim());
if (giftCertificate.IsNull)
{
return(false);
}
else
{
return(true);
}
}
public GiftCertificateRepositoryTester()
{
_giftCertificate = new GiftCertificate
{
Amount = 5.00m,
ClaimCode = "ADFDD89023kD8",
DataRecorderMetaData = new DataRecorderMetaData {
DataRecorderCreator = new OrganizationRoleUser(1), DateCreated = DateTime.Now
},
GiftCertificateTypeId = 3,
Message = "Integration Test Saving New GiftCertificate"
};
}
public void SaveUpdatesExistingGiftCertificate()
{
const decimal expectedValueAfterUpdate = -100000000m;
GiftCertificate persistedGiftCertificate = _repository.Save(_giftCertificate);
persistedGiftCertificate.Amount = expectedValueAfterUpdate;
long expectedId = persistedGiftCertificate.Id;
persistedGiftCertificate = _repository.Save(persistedGiftCertificate);
Assert.AreEqual(expectedValueAfterUpdate, persistedGiftCertificate.Amount);
Assert.AreEqual(expectedId, persistedGiftCertificate.Id);
}
public GiftCertificateModel GetModel(GiftCertificate domain)
{
return(new GiftCertificateModel
{
Amount = domain.Amount,
ClaimCode = domain.ClaimCode,
ExpirationDate = domain.ExpirationDate,
Id = domain.Id,
IsSuccess = true,
StatusCode = 200,
Message = domain.Description,
Price = domain.Price
});
}
protected GiftCertificate FindGiftCertificate(int GiftCertificateId)
{
GiftCertificate gc = null;
foreach (OrderItem orderItem in _Order.Items)
{
gc = FindGiftCertificate(orderItem, GiftCertificateId);
if (gc != null)
{
break;
}
}
return(gc);
}
public ActionResult SIMustBeInGift(string SINUmber, int?CommoditySourceID)
{
if (CommoditySourceID.HasValue && CommoditySourceID.Value == CommoditySource.Constants.DONATION)
{
var shippingInstruction = _shippingInstructionService.FindBy(t => t.Value == SINUmber).FirstOrDefault();
var mustBeInGift = new GiftCertificate();
if (shippingInstruction != null)
{
mustBeInGift = _giftCertificateService.FindBySINumber(shippingInstruction.ShippingInstructionID);
}
return(Json((mustBeInGift != null), JsonRequestBehavior.AllowGet));
}
return(Json(true, JsonRequestBehavior.AllowGet));
}
protected void LoadCertificateById(int certificateId)
{
Certificate = GiftCertificateService.GetCertificateByID(certificateId);
if (Certificate == null)
{
MsgErr("Certificate with this ID does not exist");
return;
}
lblCertificateCode.Text = Certificate.CertificateCode;
txtFromName.Text = Certificate.FromName;
txtToName.Text = Certificate.ToName;
txtSum.Text = Certificate.Sum.ToString("#0.00");
chkPaid.Checked = Certificate.Paid;
chkUsed.Checked = Certificate.Used;
rbtnEmail.Checked = Certificate.Type == CertificatePostType.Email;
rbtnMail.Checked = Certificate.Type == CertificatePostType.Mail;
chkEnable.Checked = Certificate.Enable;
txtMessage.Text = Certificate.CertificateMessage;
txtFromEmail.Text = Certificate.FromEmail;
if (Certificate.Type == CertificatePostType.Mail)
{
rbtnMail.Checked = true;
cboCountry.SelectedItem.Selected = false;
cboCountry.Items.FindByText(Certificate.Country).Selected = true;
var region = cboRegion.Items.FindByText(Certificate.Zone);
if (region != null)
{
MultiViewRegion.ActiveViewIndex = 0;
cboRegion.SelectedItem.Selected = false;
region.Selected = true;
}
else
{
MultiViewRegion.ActiveViewIndex = 1;
txtState.Text = Certificate.Zone;
}
txtCity.Text = Certificate.City;
txtZip.Text = Certificate.Zip;
txtAddress.Text = Certificate.Address;
}
else
{
rbtnEmail.Checked = true;
txtEmail.Text = Certificate.Email;
}
}
protected void BtnSave_Click(object sender, EventArgs e)
{
GiftCertificate objcreate = new GiftCertificate();
string stringstatus =objcreate.Creategiftcode(TxtCouponCode.Text.Trim(),Convert.ToInt32(TxtCouponValue.Text.Trim()),Txtremark.Text.Trim());
LblErrorMessage.Text = stringstatus;
GridView1.DataBind();
// SqlConnection con = new SqlConnection(ConnectionStrig);
// SqlCommand cmd = new SqlCommand();
// cmd.Connection = con;
// cmd.CommandText = "insert into certificatecode(CouponCode,ValueUSD,Dateissued) values(@CouponCode,@ValueUSD,@Dateissued)";
// cmd.CommandType = CommandType.Text;
// /* Passing parameters for L
// * ot Information*/
// cmd.Parameters.AddWithValue("@CouponCode", TxtCouponCode.Text.Trim());
// cmd.Parameters.AddWithValue("@ValueUSD", TxtCouponValue.Text.Trim());
// cmd.Parameters.AddWithValue("@Dateissued",couponcrtime);
// // cmd.Parameters.AddWithValue("@DateUsed", "");
// try
// {
// cmd.Connection.Open();
// int result = cmd.ExecuteNonQuery();
// if (result > 0)
// {
// string message = "Successfully inserted.";
// LblErrorMessage.Text = message;
// }
// }
// catch (SqlException ex)
// {
// string message = "Sql Error :" + ex.Message;
// LblErrorMessage.Text = message;
// }
// finally
// {
// cmd.Connection.Close();
// GridView1.DataBind();
// }
//}
//protected void BtnReset_Click(object sender, EventArgs e)
//{
// TxtCouponCode.Text = "";
// TxtCouponValue.Text = "";
//}
}
public bool EditGiftCertificate(GiftCertificate giftCertificate)
{
_unitOfWork.GiftCertificateRepository.Edit(giftCertificate);
_unitOfWork.Save();
return true;
}
/// <summary>
/// Updates the specified gift certificate model.
/// </summary>
/// <param name="giftCertificateModel">The gift certificate model.</param>
/// <param name="inserted">The inserted gift certificate detail.</param>
/// <param name="updated">The updated gift certificate detail.</param>
/// <param name="deleted">The deleted gift certificate detail.</param>
public void Update(GiftCertificate giftCertificateModel, List<GiftCertificateDetail> inserted,
List<GiftCertificateDetail> updated, List<GiftCertificateDetail> deleted)
{
// DRMFSSEntities1 db = new DRMFSSEntities1();
BLL.GiftCertificate orginal = _unitOfWork.GiftCertificateRepository.Get(p => p.GiftCertificateID == giftCertificateModel.GiftCertificateID).SingleOrDefault();
if (orginal != null)
{
orginal.GiftDate = giftCertificateModel.GiftDate;
orginal.DonorID = giftCertificateModel.DonorID;
orginal.SINumber = giftCertificateModel.SINumber;
orginal.ReferenceNo = giftCertificateModel.ReferenceNo;
orginal.Vessel = giftCertificateModel.Vessel;
orginal.ETA = giftCertificateModel.ETA;
orginal.ProgramID = giftCertificateModel.ProgramID;
orginal.PortName = giftCertificateModel.PortName;
orginal.DModeOfTransport = giftCertificateModel.DModeOfTransport;
foreach (BLL.GiftCertificateDetail insert in inserted)
{
orginal.GiftCertificateDetails.Add(insert);
}
foreach (BLL.GiftCertificateDetail delete in deleted)
{
BLL.GiftCertificateDetail deletedGiftDetails = _unitOfWork.GiftCertificateDetailRepository.FindBy(p => p.GiftCertificateDetailID == delete.GiftCertificateDetailID).SingleOrDefault();
if (deletedGiftDetails != null)
{
_unitOfWork.GiftCertificateDetailRepository.Delete(deletedGiftDetails);
}
}
foreach (BLL.GiftCertificateDetail update in updated)
{
BLL.GiftCertificateDetail updatedGiftDetails = _unitOfWork.GiftCertificateDetailRepository.Get(p => p.GiftCertificateDetailID == update.GiftCertificateDetailID).SingleOrDefault();
if (updatedGiftDetails != null)
{
updatedGiftDetails.CommodityID = update.CommodityID;
updatedGiftDetails.BillOfLoading = update.BillOfLoading;
updatedGiftDetails.YearPurchased = update.YearPurchased;
updatedGiftDetails.AccountNumber = update.AccountNumber;
updatedGiftDetails.WeightInMT = update.WeightInMT;
updatedGiftDetails.EstimatedPrice = update.EstimatedPrice;
updatedGiftDetails.EstimatedTax = update.EstimatedTax;
updatedGiftDetails.DCurrencyID = update.DCurrencyID;
updatedGiftDetails.DFundSourceID = update.DFundSourceID;
updatedGiftDetails.DBudgetTypeID = update.DBudgetTypeID;
updatedGiftDetails.ExpiryDate = update.ExpiryDate;
}
}
_unitOfWork.Save();
}
}
){kind=link}