public Int32 UpdateStore(StoreObject store)
{
try
{
if (store == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.StoreName.Trim().ToLower().Equals(store.StoreName.Trim().ToLower()) || m.StoreAlias.Trim().ToLower().Equals(store.StoreAlias.Trim().ToLower()) || m.CompanyName.Trim().ToLower().Equals(store.StoreAlias.Trim().ToLower()) && m.StoreId != store.StoreId);
if (duplicates > 0)
{
return(-3);
}
var storeEntity = ModelCrossMapper.Map <StoreObject, Store>(store);
if (storeEntity == null || storeEntity.StoreId < 1)
{
return(-2);
}
_repository.Update(storeEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateSalutation(SalutationObject salutation)
{
try
{
if (salutation == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower() == salutation.Name.Trim().ToLower() && (m.SalutationId != salutation.SalutationId));
if (duplicates > 0)
{
return(-3);
}
var salutationEntity = ModelCrossMapper.Map <SalutationObject, Salutation>(salutation);
if (salutationEntity == null || salutationEntity.SalutationId < 1)
{
return(-2);
}
_repository.Update(salutationEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateBankAccount(BankAccountObject bankAccount)
{
try
{
if (bankAccount == null)
{
return(-2);
}
if (_repository.Count(m => m.CustomerId == bankAccount.CustomerId && m.BankId == bankAccount.BankId && m.AccountName == bankAccount.AccountName && m.AccountNo == bankAccount.AccountNo && (m.BankAccountId != bankAccount.BankAccountId)) > 0)
{
return(-3);
}
var bankAccountEntity = ModelCrossMapper.Map <BankAccountObject, BankAccount>(bankAccount);
if (bankAccountEntity == null || bankAccountEntity.BankAccountId < 1)
{
return(-2);
}
_repository.Update(bankAccountEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateJobRole(JobRoleObject jobRole)
{
try
{
if (jobRole == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.JobTitle.Trim().ToLower() == jobRole.JobTitle.Trim().ToLower() && (m.JobRoleId != jobRole.JobRoleId));
if (duplicates > 0)
{
return(-3);
}
var jobRoleEntity = ModelCrossMapper.Map <JobRoleObject, JobRole>(jobRole);
if (jobRoleEntity == null || jobRoleEntity.JobRoleId < 1)
{
return(-2);
}
_repository.Update(jobRoleEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateCountry(StoreCountryObject country)
{
try
{
if (country == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower() == country.Name.Trim().ToLower() && (m.StoreCountryId != country.StoreCountryId));
if (duplicates > 0)
{
return(-3);
}
var countryEntity = ModelCrossMapper.Map <StoreCountryObject, StoreCountry>(country);
if (countryEntity == null || countryEntity.StoreCountryId < 1)
{
return(-2);
}
_repository.Update(countryEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateStoreItem(StoreItemObject storeItem)
{
try
{
if (storeItem == null)
{
return(-2);
}
if (_repository.Count(m => m.Name.Trim().ToLower() == storeItem.Name.Trim().ToLower() && m.StoreItemBrandId == storeItem.StoreItemBrandId && m.StoreItemCategoryId == storeItem.StoreItemCategoryId && m.StoreItemTypeId == storeItem.StoreItemTypeId && (m.StoreItemId != storeItem.StoreItemId)) > 0)
{
return(-3);
}
var storeItemEntity = ModelCrossMapper.Map <StoreItemObject, StoreItem>(storeItem);
if (storeItemEntity == null || storeItemEntity.StoreItemId < 1)
{
return(-2);
}
_repository.Update(storeItemEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateStoreItemType(StoreItemTypeObject productType)
{
try
{
if (productType == null)
{
return(-2);
}
if (_repository.Count(m => m.Name.Trim().ToLower() == productType.Name.Trim().ToLower() && (m.StoreItemTypeId != productType.StoreItemTypeId)) > 0)
{
return(-3);
}
var productTypeEntity = ModelCrossMapper.Map <StoreItemTypeObject, StoreItemType>(productType);
if (productTypeEntity == null || productTypeEntity.StoreItemTypeId < 1)
{
return(-2);
}
_repository.Update(productTypeEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateTransactionType(TransactionTypeObject transactionType)
{
try
{
if (transactionType == null)
{
return(-2);
}
if (_repository.Count(m => m.Name.Trim().ToLower() == transactionType.Name.Trim().ToLower() && (m.TransactionTypeId != transactionType.TransactionTypeId)) > 0)
{
return(-3);
}
var transactionTypeEntity = ModelCrossMapper.Map <TransactionTypeObject, TransactionType>(transactionType);
if (transactionTypeEntity == null || transactionTypeEntity.TransactionTypeId < 1)
{
return(-2);
}
_repository.Update(transactionTypeEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateactiveSubscription(ActiveSubscriptionObject activeSubscription)
{
try
{
if (activeSubscription == null)
{
return(-2);
}
if (_repository.Count(m => m.Name.Trim().ToLower() == activeSubscription.Name.Trim().ToLower() && m.activeSubscriptionBrandId == activeSubscription.activeSubscriptionBrandId && m.activeSubscriptionCategoryId == activeSubscription.activeSubscriptionCategoryId && m.activeSubscriptionTypeId == activeSubscription.activeSubscriptionTypeId && (m.activeSubscriptionId != activeSubscription.activeSubscriptionId)) > 0)
{
return(-3);
}
var activeSubscriptionEntity = ModelCrossMapper.Map <ActiveSubscriptionObject, activeSubscription>(activeSubscription);
if (activeSubscriptionEntity == null || activeSubscriptionEntity.activeSubscriptionId < 1)
{
return(-2);
}
_repository.Update(activeSubscriptionEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateAccountGroup(AccountGroupObject accountGroup)
{
try
{
if (accountGroup == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower() == accountGroup.Name.Trim().ToLower() && (m.AccountGroupId != accountGroup.AccountGroupId));
if (duplicates > 0)
{
return(-3);
}
var accountGroupEntity = ModelCrossMapper.Map <AccountGroupObject, AccountGroup>(accountGroup);
if (accountGroupEntity == null || accountGroupEntity.AccountGroupId < 1)
{
return(-2);
}
_repository.Update(accountGroupEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateStorePaymentGateway(StorePaymentGatewayObject storePaymentGateway)
{
try
{
if (storePaymentGateway == null)
{
return(-2);
}
if (_repository.Count(m => m.GatewayName.Trim().ToLower() == storePaymentGateway.GatewayName.Trim().ToLower() && (m.StorePaymentGatewayId != storePaymentGateway.StorePaymentGatewayId)) > 0)
{
return(-3);
}
var storePaymentGatewayEntity = ModelCrossMapper.Map <StorePaymentGatewayObject, StorePaymentGateway>(storePaymentGateway);
if (storePaymentGatewayEntity == null || storePaymentGatewayEntity.StorePaymentGatewayId < 1)
{
return(-2);
}
_repository.Update(storePaymentGatewayEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateDeliveryMethod(DeliveryMethodObject deliveryMethod)
{
try
{
if (deliveryMethod == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.MethodTitle.Trim().ToLower().Equals(deliveryMethod.MethodTitle.Trim().ToLower()) && (m.DeliveryMethodId != deliveryMethod.DeliveryMethodId));
if (duplicates > 0)
{
return(-3);
}
var deliveryMethodEntity = ModelCrossMapper.Map <DeliveryMethodObject, DeliveryMethod>(deliveryMethod);
if (deliveryMethodEntity == null || deliveryMethodEntity.DeliveryMethodId < 1)
{
return(-2);
}
_repository.Update(deliveryMethodEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public long UpdateStoreAddress(StoreAddressObject city)
{
try
{
if (city == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.StreetNo.Trim().ToLower().Equals(city.StreetNo.Trim().ToLower()) && city.StoreCityId.Equals(m.StoreCityId) && (m.StoreAddressId != city.StoreAddressId));
if (duplicates > 0)
{
var ads = _repository.GetAll(m => m.StreetNo.Trim().ToLower().Equals(city.StreetNo.Trim().ToLower()) && city.StoreCityId.Equals(m.StoreCityId)).ToList();
if (ads.Any())
{
return(ads[0].StoreAddressId);
}
}
var cityEntity = ModelCrossMapper.Map <StoreAddressObject, StoreAddress>(city);
if (cityEntity == null || cityEntity.StoreAddressId < 1)
{
return(-2);
}
_repository.Update(cityEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateStoreOutlet(StoreOutletObject storeOutlet)
{
try
{
if (storeOutlet == null)
{
return(-2);
}
if (_repository.Count(m => m.OutletName.Trim().ToLower() == storeOutlet.OutletName.Trim().ToLower() && m.StoreOutletId != storeOutlet.StoreOutletId) > 0)
{
return(-3);
}
var storeOutletEntity = ModelCrossMapper.Map <StoreOutletObject, StoreOutlet>(storeOutlet);
if (storeOutletEntity == null || storeOutletEntity.StoreOutletId < 1)
{
return(-2);
}
_repository.Update(storeOutletEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdatePaymentMethod(PaymentMethodObject paymentMethod)
{
try
{
if (paymentMethod == null)
{
return -2;
}
if (_repository.Count(m => m.Name.Trim().ToLower() == paymentMethod.Name.Trim().ToLower() && (m.PaymentMethodId != paymentMethod.PaymentMethodId)) > 0)
{
return -3;
}
var paymentMethodEntity = ModelCrossMapper.Map<PaymentMethodObject, PaymentMethod>(paymentMethod);
if (paymentMethodEntity == null || paymentMethodEntity.PaymentMethodId < 1)
{
return -2;
}
_repository.Update(paymentMethodEntity);
_uoWork.SaveChanges();
return 5;
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return -2;
}
}
public int UpdateSubscriptionPackage(SubscriptionPackageObject subscriptionPackage)
{
try
{
if (subscriptionPackage == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.PackageTitle.Trim().ToLower() == subscriptionPackage.PackageTitle.Trim().ToLower() &&
subscriptionPackage.FileStorageSpace == m.FileStorageSpace && m.NumberOfOutlets == subscriptionPackage.NumberOfOutlets &&
m.Registers == subscriptionPackage.Registers && m.NumberOfUsers == subscriptionPackage.NumberOfUsers &&
m.MaximumTransactions == subscriptionPackage.MaximumTransactions && (m.SubscriptionPackageId != subscriptionPackage.SubscriptionPackageId));
if (duplicates > 0)
{
return(-3);
}
var subscriptionPackageEntity = ModelCrossMapper.Map <SubscriptionPackageObject, SubscriptionPackage>(subscriptionPackage);
if (subscriptionPackageEntity == null || subscriptionPackageEntity.SubscriptionPackageId < 1)
{
return(-2);
}
_repository.Update(subscriptionPackageEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateSupplier(SupplierObject supplier)
{
try
{
if (supplier == null)
{
return(-2);
}
var duplicates = _repository.Count(m => (m.CompanyName.Trim().ToLower() == supplier.CompanyName.Trim().ToLower() || m.TIN != null && supplier.TIN != null && m.TIN.Trim() == supplier.TIN.Trim()) && (m.SupplierId != supplier.SupplierId));
if (duplicates > 0)
{
return(-3);
}
var supplierEntity = ModelCrossMapper.Map <SupplierObject, Supplier>(supplier);
if (supplierEntity == null || supplierEntity.SupplierId < 1)
{
return(-2);
}
_repository.Update(supplierEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateStoreSetting(StoreSettingObject storeSetting)
{
try
{
if (storeSetting == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.StoreId == storeSetting.StoreId && (m.StoreId != storeSetting.StoreId));
if (duplicates > 0)
{
return(-3);
}
var storeSettingEntity = ModelCrossMapper.Map <StoreSettingObject, StoreSetting>(storeSetting);
if (storeSettingEntity == null || storeSettingEntity.StoreId < 1)
{
return(-2);
}
_repository.Update(storeSettingEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateBank(BankObject bank)
{
try
{
if (bank == null)
{
return(-2);
}
if (_repository.Count(m => m.FullName.Trim().ToLower() == bank.FullName.Trim().ToLower() && (m.BankId != bank.BankId)) > 0)
{
return(-3);
}
if (_repository.Count(m => m.SortCode.Trim().ToLower() == bank.SortCode.Trim().ToLower() && (m.BankId != bank.BankId)) > 0)
{
return(-4);
}
var bankEntity = ModelCrossMapper.Map <BankObject, Bank>(bank);
if (bankEntity == null || bankEntity.BankId < 1)
{
return(-2);
}
_repository.Update(bankEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public Int32 UpdateCompany(CompanyObject company)
{
try
{
if (company == null)
{
return(-2);
}
if (_repository.Count(m => m.Name.Trim().ToLower() == company.Name.Trim().ToLower() && (m.CompanyId != company.CompanyId)) > 0)
{
return(-3);
}
var companyEntity = ModelCrossMapper.Map <CompanyObject, Company>(company);
if (companyEntity == null || companyEntity.CompanyId < 1)
{
return(-2);
}
_repository.Update(companyEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateBillingCycle(BillingCycleObject billingCycle)
{
try
{
if (billingCycle == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower().Equals(billingCycle.Name.Trim().ToLower()) || m.Code.Equals(billingCycle.Code) && (m.BillingCycleId != billingCycle.BillingCycleId));
if (duplicates > 0)
{
return(-3);
}
var billingCycleEntity = ModelCrossMapper.Map <BillingCycleObject, BillingCycle>(billingCycle);
if (billingCycleEntity == null || billingCycleEntity.BillingCycleId < 1)
{
return(-2);
}
_repository.Update(billingCycleEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateCoupon(CouponObject coupon)
{
try
{
if (coupon == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Title.Trim().ToLower() == coupon.Code.Trim().ToLower() && m.ValidFrom == coupon.ValidFrom && m.ValidTo == coupon.ValidTo && (m.CouponId != coupon.CouponId));
if (duplicates > 0)
{
return(-3);
}
var couponEntity = ModelCrossMapper.Map <CouponObject, Coupon>(coupon);
if (couponEntity == null || couponEntity.CouponId < 1)
{
return(-2);
}
_repository.Update(couponEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateImageView(ImageViewObject imageView)
{
try
{
if (imageView == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower() == imageView.Name.Trim().ToLower() && (m.ImageViewId != imageView.ImageViewId));
if (duplicates > 0)
{
return(-3);
}
var imageViewEntity = ModelCrossMapper.Map <ImageViewObject, ImageView>(imageView);
if (imageViewEntity == null || imageViewEntity.ImageViewId < 1)
{
return(-2);
}
_repository.Update(imageViewEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateChartOfAccount(ChartOfAccountObject chartOfAccount)
{
try
{
if (chartOfAccount == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.AccountType.Trim().ToLower() == chartOfAccount.AccountType.Trim().ToLower() && m.AccountCode.Trim().ToLower() == chartOfAccount.AccountCode.Trim().ToLower() && chartOfAccount.AccountGroupId == m.AccountGroupId && (m.ChartOfAccountId != chartOfAccount.ChartOfAccountId));
if (duplicates > 0)
{
return(-3);
}
var chartOfAccountEntity = ModelCrossMapper.Map <ChartOfAccountObject, ChartOfAccount>(chartOfAccount);
if (chartOfAccountEntity == null || chartOfAccountEntity.ChartOfAccountId < 1)
{
return(-2);
}
_repository.Update(chartOfAccountEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateUnitsOfMeasurement(UnitsOfMeasurementObject unitsOfMeasurement)
{
try
{
if (unitsOfMeasurement == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.UoMCode.Trim().ToLower() == unitsOfMeasurement.UoMCode.Trim().ToLower() && (m.UnitOfMeasurementId != unitsOfMeasurement.UnitOfMeasurementId));
if (duplicates > 0)
{
return(-3);
}
var unitsOfMeasurementEntity = ModelCrossMapper.Map <UnitsOfMeasurementObject, UnitsOfMeasurement>(unitsOfMeasurement);
if (unitsOfMeasurementEntity == null || unitsOfMeasurementEntity.UnitOfMeasurementId < 1)
{
return(-2);
}
_repository.Update(unitsOfMeasurementEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateCity(CityObject city)
{
try
{
if (city == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower().Equals(city.Name.Trim().ToLower()) && city.StateId.Equals(m.StateId) && (m.CityId != city.CityId));
if (duplicates > 0)
{
return(-3);
}
var cityEntity = ModelCrossMapper.Map <CityObject, City>(city);
if (cityEntity == null || cityEntity.CityId < 1)
{
return(-2);
}
_repository.Update(cityEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateRegister(RegisterObject register)
{
try
{
if (register == null)
{
return -2;
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower().Equals(register.Name.Trim().ToLower()) && register.CurrentOutletId.Equals(m.CurrentOutletId) && (m.RegisterId != register.RegisterId));
if (duplicates > 0)
{
return -3;
}
var registerEntity = ModelCrossMapper.Map<RegisterObject, Register>(register);
if (registerEntity == null || registerEntity.RegisterId < 1)
{
return -2;
}
_repository.Update(registerEntity);
_uoWork.SaveChanges();
return 5;
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return -2;
}
}
public int UpdateUserProfile(UserProfileObject person)
{
try
{
if (person == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.LastName.Trim().ToLower() == person.LastName.Trim().ToLower() && m.OtherNames.Trim().ToLower() == person.OtherNames.Trim().ToLower() && (m.Id != person.Id));
if (duplicates > 0)
{
return(-3);
}
var personEntity = ModelCrossMapper.Map <UserProfileObject, UserProfile>(person);
if (personEntity == null)
{
return(-2);
}
_repository.Update(personEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdatePaymentType(PaymentTypeObject paymentType)
{
try
{
if (paymentType == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower() == paymentType.Name.Trim().ToLower() && (m.PaymentTypeId != paymentType.PaymentTypeId));
if (duplicates > 0)
{
return(-3);
}
var paymentTypeEntity = ModelCrossMapper.Map <PaymentTypeObject, PaymentType>(paymentType);
if (paymentTypeEntity == null || paymentTypeEntity.PaymentTypeId < 1)
{
return(-2);
}
_repository.Update(paymentTypeEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
public int UpdateStoreDepartment(StoreDepartmentObject storeDepartment)
{
try
{
if (storeDepartment == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.Name.Trim().ToLower() == storeDepartment.Name.Trim().ToLower() && (m.StoreDepartmentId != storeDepartment.StoreDepartmentId));
if (duplicates > 0)
{
return(-3);
}
var storeDepartmentEntity = ModelCrossMapper.Map <StoreDepartmentObject, StoreDepartment>(storeDepartment);
if (storeDepartmentEntity == null || storeDepartmentEntity.StoreDepartmentId < 1)
{
return(-2);
}
_repository.Update(storeDepartmentEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
