public CityObject GetCity(long cityId)
{
try
{
var myItem = _repository.GetById(cityId);
if (myItem == null || myItem.CityId < 1)
{
return(new CityObject());
}
var cityObject = ModelCrossMapper.Map <City, CityObject>(myItem);
if (cityObject == null || cityObject.CityId < 1)
{
return(new CityObject());
}
return(cityObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new CityObject());
}
}
public AlaCarteObject GetAlaCarte(long alaCarteId)
{
try
{
var myItem = _repository.GetById(alaCarteId);
if (myItem == null || myItem.AlaCarteId < 1)
{
return(new AlaCarteObject());
}
var alaCarteObject = ModelCrossMapper.Map <AlaCarte, AlaCarteObject>(myItem);
if (alaCarteObject == null || alaCarteObject.AlaCarteId < 1)
{
return(new AlaCarteObject());
}
return(alaCarteObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new AlaCarteObject());
}
}
public MessageTemplateObject GetMessageTemplate(int messageEventId)
{
try
{
using (var db = _db)
{
var templates = db.MessageTemplates.Where(m => m.EventTypeId == messageEventId).ToList();
var app = templates[0];
var messageTemplateObject = ModelCrossMapper.Map <MessageTemplate, MessageTemplateObject>(app);
if (messageTemplateObject == null || messageTemplateObject.Id < 1)
{
return(new MessageTemplateObject());
}
return(messageTemplateObject);
}
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new MessageTemplateObject());
}
}
public PaymentGatewayObject GetPaymentGateway(long paymentGatewayId)
{
try
{
var myItem = _repository.GetById(paymentGatewayId);
if (myItem == null || myItem.PaymentGatewayId < 1)
{
return(new PaymentGatewayObject());
}
var paymentGatewayObject = ModelCrossMapper.Map <PaymentGateway, PaymentGatewayObject>(myItem);
if (paymentGatewayObject == null || paymentGatewayObject.PaymentGatewayId < 1)
{
return(new PaymentGatewayObject());
}
return(paymentGatewayObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new PaymentGatewayObject());
}
}
public ImageViewObject GetImageView(long imageViewId)
{
try
{
var myItem = _repository.GetById(imageViewId);
if (myItem == null || myItem.ImageViewId < 1)
{
return(new ImageViewObject());
}
var imageViewObject = ModelCrossMapper.Map <ImageView, ImageViewObject>(myItem);
if (imageViewObject == null || imageViewObject.ImageViewId < 1)
{
return(new ImageViewObject());
}
return(imageViewObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new ImageViewObject());
}
}
public ChartOfAccountObject GetChartOfAccount(long chartOfAccountId)
{
try
{
var myItem = _repository.GetById(chartOfAccountId);
if (myItem == null || myItem.ChartOfAccountId < 1)
{
return(new ChartOfAccountObject());
}
var chartOfAccountObject = ModelCrossMapper.Map <ChartOfAccount, ChartOfAccountObject>(myItem);
if (chartOfAccountObject == null || chartOfAccountObject.ChartOfAccountId < 1)
{
return(new ChartOfAccountObject());
}
return(chartOfAccountObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new ChartOfAccountObject());
}
}
public StoreItemTypeObject GetStoreItemType(long productTypeId)
{
try
{
var myItem = _repository.GetById(productTypeId);
if (myItem == null || myItem.StoreItemTypeId < 1)
{
return(new StoreItemTypeObject());
}
var productTypeObject = ModelCrossMapper.Map <StoreItemType, StoreItemTypeObject>(myItem);
if (productTypeObject == null || productTypeObject.StoreItemTypeId < 1)
{
return(new StoreItemTypeObject());
}
return(productTypeObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new StoreItemTypeObject());
}
}
public BillingCycleObject GetBillingCycle(long billingCycleId)
{
try
{
var myItem = _repository.GetById(billingCycleId);
if (myItem == null || myItem.BillingCycleId < 1)
{
return(new BillingCycleObject());
}
var billingCycleObject = ModelCrossMapper.Map <BillingCycle, BillingCycleObject>(myItem);
if (billingCycleObject == null || billingCycleObject.BillingCycleId < 1)
{
return(new BillingCycleObject());
}
return(billingCycleObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new BillingCycleObject());
}
}
public List <DeliveryMethodObject> GetDeliveryMethodObjects(int?itemsPerPage, int?pageNumber)
{
try
{
List <DeliveryMethod> deliveryMethodEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
deliveryMethodEntityList = _repository.GetWithPaging(m => m.DeliveryMethodId, tpageNumber, tsize).ToList();
}
else
{
deliveryMethodEntityList = _repository.GetAll().ToList();
}
if (!deliveryMethodEntityList.Any())
{
return(new List <DeliveryMethodObject>());
}
var deliveryMethodObjList = new List <DeliveryMethodObject>();
deliveryMethodEntityList.ForEach(m =>
{
var deliveryMethodObject = ModelCrossMapper.Map <DeliveryMethod, DeliveryMethodObject>(m);
if (deliveryMethodObject != null && deliveryMethodObject.DeliveryMethodId > 0)
{
deliveryMethodObjList.Add(deliveryMethodObject);
}
});
return(deliveryMethodObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <DeliveryMethodObject>());
}
}
public BankObject GetBank(long bankId)
{
try
{
var myItem = _repository.GetById(bankId);
if (myItem == null || myItem.BankId < 1)
{
return(new BankObject());
}
var bankObject = ModelCrossMapper.Map <Bank, BankObject>(myItem);
if (bankObject == null || bankObject.BankId < 1)
{
return(new BankObject());
}
return(bankObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new BankObject());
}
}
public List<SaleTransactionObject> GetSaleTransactionObjects(int? itemsPerPage, int? pageNumber)
{
try
{
List<SaleTransaction> saleTransactionEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
saleTransactionEntityList = _repository.GetWithPaging(m => m.SaleTransactionId, tpageNumber, tsize).ToList();
}
else
{
saleTransactionEntityList = _repository.GetAll().ToList();
}
if (!saleTransactionEntityList.Any())
{
return new List<SaleTransactionObject>();
}
var saleTransactionObjList = new List<SaleTransactionObject>();
saleTransactionEntityList.ForEach(m =>
{
var saleTransactionObject = ModelCrossMapper.Map<SaleTransaction, SaleTransactionObject>(m);
if (saleTransactionObject != null && saleTransactionObject.SaleTransactionId > 0)
{
saleTransactionObjList.Add(saleTransactionObject);
}
});
return saleTransactionObjList;
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return new List<SaleTransactionObject>();
}
}
public DeliveryMethodObject GetDeliveryMethod(long deliveryMethodId)
{
try
{
var myItem = _repository.GetById(deliveryMethodId);
if (myItem == null || myItem.DeliveryMethodId < 1)
{
return(new DeliveryMethodObject());
}
var deliveryMethodObject = ModelCrossMapper.Map <DeliveryMethod, DeliveryMethodObject>(myItem);
if (deliveryMethodObject == null || deliveryMethodObject.DeliveryMethodId < 1)
{
return(new DeliveryMethodObject());
}
return(deliveryMethodObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new DeliveryMethodObject());
}
}
public SaleTransactionObject GetSaleTransaction(long saleTransactionId)
{
try
{
var myItem = _repository.GetById(saleTransactionId);
if (myItem == null || myItem.SaleTransactionId < 1)
{
return new SaleTransactionObject();
}
var saleTransactionObject = ModelCrossMapper.Map<SaleTransaction, SaleTransactionObject>(myItem);
if (saleTransactionObject == null || saleTransactionObject.SaleTransactionId < 1)
{
return new SaleTransactionObject();
}
return saleTransactionObject;
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return new SaleTransactionObject();
}
}
public StoreCurrencyObject GetStoreCurrency(long currencyId)
{
try
{
var myItem = _repository.GetById(currencyId);
if (myItem == null || myItem.StoreCurrencyId < 1)
{
return(new StoreCurrencyObject());
}
var currencyObject = ModelCrossMapper.Map <StoreCurrency, StoreCurrencyObject>(myItem);
if (currencyObject == null || currencyObject.StoreCurrencyId < 1)
{
return(new StoreCurrencyObject());
}
return(currencyObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new StoreCurrencyObject());
}
}
public List <StoreOutletObject> GetStoreOutletObjects(int?itemsPerPage, int?pageNumber)
{
try
{
List <StoreOutlet> storeOutletEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
storeOutletEntityList = _repository.GetWithPaging(m => m.StoreOutletId, tpageNumber, tsize, "StoreAddress").ToList();
}
else
{
storeOutletEntityList = _repository.GetAll("StoreAddress").ToList();
}
if (!storeOutletEntityList.Any())
{
return(new List <StoreOutletObject>());
}
var storeOutletObjList = new List <StoreOutletObject>();
storeOutletEntityList.ForEach(m =>
{
var storeOutletObject = ModelCrossMapper.Map <StoreOutlet, StoreOutletObject>(m);
if (storeOutletObject != null && storeOutletObject.StoreOutletId > 0)
{
storeOutletObjList.Add(storeOutletObject);
}
});
return(storeOutletObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <StoreOutletObject>());
}
}
public StoreDepartmentObject GetStoreDepartment(long storeDepartmentId)
{
try
{
var myItem = _repository.GetById(storeDepartmentId);
if (myItem == null || myItem.StoreDepartmentId < 1)
{
return(new StoreDepartmentObject());
}
var storeDepartmentObject = ModelCrossMapper.Map <StoreDepartment, StoreDepartmentObject>(myItem);
if (storeDepartmentObject == null || storeDepartmentObject.StoreDepartmentId < 1)
{
return(new StoreDepartmentObject());
}
return(storeDepartmentObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new StoreDepartmentObject());
}
}
public AccountGroupObject GetAccountGroup(long accountGroupId)
{
try
{
var myItem = _repository.GetById(accountGroupId);
if (myItem == null || myItem.AccountGroupId < 1)
{
return(new AccountGroupObject());
}
var accountGroupObject = ModelCrossMapper.Map <AccountGroup, AccountGroupObject>(myItem);
if (accountGroupObject == null || accountGroupObject.AccountGroupId < 1)
{
return(new AccountGroupObject());
}
return(accountGroupObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new AccountGroupObject());
}
}
public TransactionTypeObject GetTransactionType(long transactionTypeId)
{
try
{
var myItem = _repository.GetById(transactionTypeId);
if (myItem == null || myItem.TransactionTypeId < 1)
{
return(new TransactionTypeObject());
}
var transactionTypeObject = ModelCrossMapper.Map <TransactionType, TransactionTypeObject>(myItem);
if (transactionTypeObject == null || transactionTypeObject.TransactionTypeId < 1)
{
return(new TransactionTypeObject());
}
return(transactionTypeObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new TransactionTypeObject());
}
}
public List <AccountGroupObject> GetAccountGroupObject(int?itemsPerPage, int?pageNumber)
{
try
{
List <AccountGroup> accountGroupEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
accountGroupEntityList = _repository.GetWithPaging(m => m.AccountGroupId, tpageNumber, tsize).ToList();
}
else
{
accountGroupEntityList = _repository.GetAll().ToList();
}
if (!accountGroupEntityList.Any())
{
return(new List <AccountGroupObject>());
}
var accountGroupObjList = new List <AccountGroupObject>();
accountGroupEntityList.ForEach(m =>
{
var accountGroupObject = ModelCrossMapper.Map <AccountGroup, AccountGroupObject>(m);
if (accountGroupObject != null && accountGroupObject.AccountGroupId > 0)
{
accountGroupObjList.Add(accountGroupObject);
}
});
return(accountGroupObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <AccountGroupObject>());
}
}
public List <StoreContactTagObject> GetContactTagObjects(int?itemsPerPage, int?pageNumber)
{
try
{
List <StoreContactTag> contactTagEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
contactTagEntityList = _repository.GetWithPaging(m => m.ContactTagId, tpageNumber, tsize).ToList();
}
else
{
contactTagEntityList = _repository.GetAll().ToList();
}
if (!contactTagEntityList.Any())
{
return(new List <StoreContactTagObject>());
}
var contactTagObjList = new List <StoreContactTagObject>();
contactTagEntityList.ForEach(m =>
{
var contactTagObject = ModelCrossMapper.Map <StoreContactTag, StoreContactTagObject>(m);
if (contactTagObject != null && contactTagObject.ContactTagId > 0)
{
contactTagObjList.Add(contactTagObject);
}
});
return(contactTagObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <StoreContactTagObject>());
}
}
public StoreSettingObject GetStoreSetting(long storeId)
{
try
{
var myItem = _repository.Get(m => m.StoreId == storeId, "Store");
if (myItem == null || myItem.StoreId < 1)
{
return(new StoreSettingObject());
}
var storeSettingObject = ModelCrossMapper.Map <StoreSetting, StoreSettingObject>(myItem);
if (storeSettingObject == null || storeSettingObject.StoreId < 1)
{
return(new StoreSettingObject());
}
return(storeSettingObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new StoreSettingObject());
}
}
public List <StoreItemTypeObject> GetStoreItemTypeObjects(int?itemsPerPage, int?pageNumber)
{
try
{
List <StoreItemType> productTypeEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
productTypeEntityList = _repository.GetWithPaging(m => m.StoreItemTypeId, tpageNumber, tsize).ToList();
}
else
{
productTypeEntityList = _repository.GetAll().ToList();
}
if (!productTypeEntityList.Any())
{
return(new List <StoreItemTypeObject>());
}
var productTypeObjList = new List <StoreItemTypeObject>();
productTypeEntityList.ForEach(m =>
{
var productTypeObject = ModelCrossMapper.Map <StoreItemType, StoreItemTypeObject>(m);
if (productTypeObject != null && productTypeObject.StoreItemTypeId > 0)
{
productTypeObjList.Add(productTypeObject);
}
});
return(productTypeObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <StoreItemTypeObject>());
}
}
public List <ImageViewObject> GetImageViewObjects(int?itemsPerPage, int?pageNumber)
{
try
{
List <ImageView> imageViewEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
imageViewEntityList = _repository.GetWithPaging(m => m.ImageViewId, tpageNumber, tsize).ToList();
}
else
{
imageViewEntityList = _repository.GetAll().ToList();
}
if (!imageViewEntityList.Any())
{
return(new List <ImageViewObject>());
}
var imageViewObjList = new List <ImageViewObject>();
imageViewEntityList.ForEach(m =>
{
var imageViewObject = ModelCrossMapper.Map <ImageView, ImageViewObject>(m);
if (imageViewObject != null && imageViewObject.ImageViewId > 0)
{
imageViewObjList.Add(imageViewObject);
}
});
return(imageViewObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <ImageViewObject>());
}
}
public List <BillingCycleObject> GetBillingCycleObjects(int?itemsPerPage, int?pageNumber)
{
try
{
List <BillingCycle> billingCycleEntityList;
if ((itemsPerPage != null && itemsPerPage > 0) && (pageNumber != null && pageNumber >= 0))
{
var tpageNumber = (int)pageNumber;
var tsize = (int)itemsPerPage;
billingCycleEntityList = _repository.GetWithPaging(m => m.BillingCycleId, tpageNumber, tsize).ToList();
}
else
{
billingCycleEntityList = _repository.GetAll().ToList();
}
if (!billingCycleEntityList.Any())
{
return(new List <BillingCycleObject>());
}
var billingCycleObjList = new List <BillingCycleObject>();
billingCycleEntityList.ForEach(m =>
{
var billingCycleObject = ModelCrossMapper.Map <BillingCycle, BillingCycleObject>(m);
if (billingCycleObject != null && billingCycleObject.BillingCycleId > 0)
{
billingCycleObjList.Add(billingCycleObject);
}
});
return(billingCycleObjList);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new List <BillingCycleObject>());
}
}
public DocumentTypeObject GetDocumentType(long documentTypeId)
{
try
{
var myItem = _repository.GetById(documentTypeId);
if (myItem == null || myItem.DocumentTypeId < 1)
{
return(new DocumentTypeObject());
}
var documentTypeObject = ModelCrossMapper.Map <DocumentType, DocumentTypeObject>(myItem);
if (documentTypeObject == null || documentTypeObject.DocumentTypeId < 1)
{
return(new DocumentTypeObject());
}
return(documentTypeObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new DocumentTypeObject());
}
}
public ShoppingCartObject GetShoppingCart(long shoppingCartId)
{
try
{
using (var db = _dbStoreEntities)
{
var item = from sh in db.ShoppingCarts
where sh.ShoppingCartId == shoppingCartId
join cs in db.Customers on sh.CustomerId equals cs.CustomerId
join ps in db.UserProfiles on cs.UserId equals ps.Id
join si in db.ShopingCartItems on sh.ShoppingCartId equals si.ShopingCartId
join st in db.StoreItemStocks on si.ShopingCartItemId equals st.StoreItemStockId
join sti in db.StoreItems on st.StoreItemId equals sti.StoreItemId
join sp in db.StoreItemTypes on sti.StoreItemTypeId equals sp.StoreItemTypeId
join sb in db.StoreItemBrands on sti.StoreItemBrandId equals sb.StoreItemBrandId
join sc in db.StoreItemCategories on sti.StoreItemCategoryId equals sc.StoreItemCategoryId
join um in db.UnitsOfMeasurements on si.UoMId equals um.UnitOfMeasurementId
select new{ sh, cs, ps, si, st, sti, sp, sb, sc, um };
}
var myItem = _repository.Get(m => m.ShoppingCartId == shoppingCartId, "Customer, ShopingCartItems");
if (myItem == null || myItem.ShoppingCartId < 1)
{
return(new ShoppingCartObject());
}
var shoppingCartObject = ModelCrossMapper.Map <ShoppingCart, ShoppingCartObject>(myItem);
if (shoppingCartObject == null || shoppingCartObject.ShoppingCartId < 1)
{
return(new ShoppingCartObject());
}
return(shoppingCartObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new ShoppingCartObject());
}
}
public Int32 UpdateStoreContact(StoreContactObject storeContact)
{
try
{
if (storeContact == null)
{
return(-2);
}
var storeContactEntity = ModelCrossMapper.Map <StoreContactObject, StoreContact>(storeContact);
if (storeContactEntity == null || storeContactEntity.StoreContactId < 1)
{
return(-2);
}
_repository.Update(storeContactEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public StoreAddressObject GetStoreAddress()
{
try
{
var myItem = _repository.GetAll("StoreCity").ToList()[0];
if (myItem == null || myItem.StoreAddressId < 1)
{
return(new StoreAddressObject());
}
var cityObject = ModelCrossMapper.Map <StoreAddress, StoreAddressObject>(myItem);
if (cityObject == null || cityObject.StoreAddressId < 1)
{
return(new StoreAddressObject());
}
cityObject.StreetNo = myItem.StreetNo + ", " + myItem.StoreCity.Name;
return(cityObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new StoreAddressObject());
}
}
public int UpdateStoreItemSold(StoreItemSoldObject itemSold)
{
try
{
if (itemSold == null)
{
return(-2);
}
var itemSoldEntity = ModelCrossMapper.Map <StoreItemSoldObject, StoreItemSold>(itemSold);
if (itemSoldEntity == null || itemSoldEntity.StoreItemSoldId < 1)
{
return(-2);
}
_repository.Update(itemSoldEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public CouponObject GetCoupon(long couponId)
{
try
{
var myItem = _repository.GetById(couponId);
if (myItem == null || myItem.CouponId < 1)
{
return(new CouponObject());
}
var couponObject = ModelCrossMapper.Map <Coupon, CouponObject>(myItem);
if (couponObject == null || couponObject.CouponId < 1)
{
return(new CouponObject());
}
couponObject.ValidityPeriod = couponObject.ValidFrom.ToString("dd/MM/yyyy") + " - " + couponObject.ValidTo.ToString("dd/MM/yyyy");
return(couponObject);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(new CouponObject());
}
}