/// <summary>
/// Converts from primary weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="targetMeasureWeight">Target weight</param>
/// <returns>Converted value</returns>
public virtual async Task <decimal> ConvertFromPrimaryMeasureWeight(decimal value,
MeasureWeight targetMeasureWeight)
{
if (targetMeasureWeight == null)
{
throw new ArgumentNullException("targetMeasureWeight");
}
decimal result = value;
var baseWeightIn = await GetMeasureWeightById(_measureSettings.BaseWeightId);
if (result != decimal.Zero && targetMeasureWeight.Id != baseWeightIn.Id)
{
decimal exchangeRatio = targetMeasureWeight.Ratio;
if (exchangeRatio == decimal.Zero)
{
throw new GrandException(string.Format("Exchange ratio not set for weight [{0}]", targetMeasureWeight.Name));
}
result = result * exchangeRatio;
}
return(result);
}
public ActionResult WeightAdd([Bind(Exclude = "Id")] MeasureWeightModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMeasures))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult()
{
Errors = ModelState.SerializeErrors()
}));
}
var weight = new MeasureWeight();
weight = model.ToEntity(weight);
_measureService.InsertMeasureWeight(weight);
return(new NullJsonResult());
}
/// <summary>
/// Converts from primary weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="targetMeasureWeight">Target weight</param>
/// <returns>Converted value</returns>
public virtual decimal ConvertFromPrimaryMeasureWeight(decimal value,
MeasureWeight targetMeasureWeight)
{
if (targetMeasureWeight == null)
{
throw new ArgumentNullException(nameof(targetMeasureWeight));
}
var result = value;
var baseWeightIn = GetMeasureWeightById(_measureSettings.BaseWeightId);
if (result != decimal.Zero && targetMeasureWeight.Id != baseWeightIn.Id)
{
var exchangeRatio = targetMeasureWeight.Ratio;
if (exchangeRatio == decimal.Zero)
{
throw new NopException($"Exchange ratio not set for weight [{targetMeasureWeight.Name}]");
}
result = result * exchangeRatio;
}
return(result);
}
public virtual IActionResult WeightAdd(MeasureWeightModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageShippingSettings))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(ErrorJson(ModelState.SerializeErrors()));
}
var weight = new MeasureWeight();
weight = model.ToEntity(weight);
_measureService.InsertMeasureWeight(weight);
//activity log
_customerActivityService.InsertActivity("AddNewMeasureWeight",
string.Format(_localizationService.GetResource("ActivityLog.AddNewMeasureWeight"), weight.Id), weight);
return(Json(new { Result = true }));
}
public virtual ActionResult WeightAdd([Bind(Exclude = "Id")] MeasureWeightModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageShippingSettings))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var weight = new MeasureWeight();
weight = model.ToEntity(weight);
_measureService.InsertMeasureWeight(weight);
//activity log
_customerActivityService.InsertActivity("AddNewMeasureWeight", _localizationService.GetResource("ActivityLog.AddNewMeasureWeight"), weight.Id);
return(new NullJsonResult());
}
public static MeasureWeight ToEntity(this MeasureWeightModel model, MeasureWeight destination)
{
return(Mapper.Map(model, destination));
}
private int ConvertFromPrimaryMeasureWeight(decimal quantity, MeasureWeight usedMeasureWeighht)
{
return(Convert.ToInt32(Math.Ceiling(_measureService.ConvertFromPrimaryMeasureWeight(quantity, usedMeasureWeighht))));
}
public static MeasureWeightModel ToModel(this MeasureWeight entity)
{
return(Mapper.Map <MeasureWeight, MeasureWeightModel>(entity));
}
public new void SetUp()
{
measureDimension1 = new MeasureDimension()
{
Id = 1,
Name = "inch(es)",
SystemKeyword = "inch",
Ratio = 1M,
DisplayOrder = 1,
};
measureDimension2 = new MeasureDimension()
{
Id = 2,
Name = "feet",
SystemKeyword = "ft",
Ratio = 0.08333333M,
DisplayOrder = 2,
};
measureDimension3 = new MeasureDimension()
{
Id = 3,
Name = "meter(s)",
SystemKeyword = "m",
Ratio = 0.0254M,
DisplayOrder = 3,
};
measureDimension4 = new MeasureDimension()
{
Id = 4,
Name = "millimetre(s)",
SystemKeyword = "mm",
Ratio = 25.4M,
DisplayOrder = 4,
};
measureWeight1 = new MeasureWeight()
{
Id = 1,
Name = "ounce(s)",
SystemKeyword = "oz",
Ratio = 16M,
DisplayOrder = 1,
};
measureWeight2 = new MeasureWeight()
{
Id = 2,
Name = "lb(s)",
SystemKeyword = "lb",
Ratio = 1M,
DisplayOrder = 2,
};
measureWeight3 = new MeasureWeight()
{
Id = 3,
Name = "kg(s)",
SystemKeyword = "kg",
Ratio = 0.45359237M,
DisplayOrder = 3,
};
measureWeight4 = new MeasureWeight()
{
Id = 4,
Name = "gram(s)",
SystemKeyword = "g",
Ratio = 453.59237M,
DisplayOrder = 4,
};
_measureDimensionRepository = MockRepository.GenerateMock <IRepository <MeasureDimension> >();
_measureDimensionRepository.Expect(x => x.Table).Return(new List <MeasureDimension>()
{
measureDimension1, measureDimension2, measureDimension3, measureDimension4
}.AsQueryable());
_measureDimensionRepository.Expect(x => x.GetById(measureDimension1.Id)).Return(measureDimension1);
_measureDimensionRepository.Expect(x => x.GetById(measureDimension2.Id)).Return(measureDimension2);
_measureDimensionRepository.Expect(x => x.GetById(measureDimension3.Id)).Return(measureDimension3);
_measureDimensionRepository.Expect(x => x.GetById(measureDimension4.Id)).Return(measureDimension4);
_measureWeightRepository = MockRepository.GenerateMock <IRepository <MeasureWeight> >();
_measureWeightRepository.Expect(x => x.Table).Return(new List <MeasureWeight>()
{
measureWeight1, measureWeight2, measureWeight3, measureWeight4
}.AsQueryable());
_measureWeightRepository.Expect(x => x.GetById(measureWeight1.Id)).Return(measureWeight1);
_measureWeightRepository.Expect(x => x.GetById(measureWeight2.Id)).Return(measureWeight2);
_measureWeightRepository.Expect(x => x.GetById(measureWeight3.Id)).Return(measureWeight3);
_measureWeightRepository.Expect(x => x.GetById(measureWeight4.Id)).Return(measureWeight4);
var cacheManager = new NullCache();
_measureSettings = new MeasureSettings();
_measureSettings.BaseDimensionId = measureDimension1.Id; //inch(es)
_measureSettings.BaseWeightId = measureWeight2.Id; //lb(s)
_eventPublisher = MockRepository.GenerateMock <IEventPublisher>();
_eventPublisher.Expect(x => x.Publish(Arg <object> .Is.Anything));
_measureService = new MeasureService(cacheManager,
_measureDimensionRepository,
_measureWeightRepository,
_measureSettings, _eventPublisher);
}
public virtual decimal ConvertWeight(decimal quantity, MeasureWeight sourceMeasureWeight, MeasureWeight targetMeasureWeight, bool round = true)
{
decimal result = quantity;
if (result != decimal.Zero && sourceMeasureWeight.Id != targetMeasureWeight.Id)
{
result = ConvertToPrimaryMeasureWeight(result, sourceMeasureWeight);
result = ConvertFromPrimaryMeasureWeight(result, targetMeasureWeight);
}
if (round)
{
result = Math.Round(result, 2);
}
return(result);
}
/// <summary>
/// Updates the measure weight
/// </summary>
/// <param name="measure">Measure weight</param>
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task UpdateMeasureWeightAsync(MeasureWeight measure)
{
await _measureWeightRepository.UpdateAsync(measure);
}
/// <summary>
/// Deletes measure weight
/// </summary>
/// <param name="measureWeight">Measure weight</param>
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task DeleteMeasureWeightAsync(MeasureWeight measureWeight)
{
await _measureWeightRepository.DeleteAsync(measureWeight);
}
/// <summary>
/// Deletes measure weight
/// </summary>
/// <param name="measureWeight">Measure weight</param>
public void DeleteMeasureWeight(MeasureWeight measureWeight)
{
_measureService.DeleteMeasureWeight(measureWeight);
}
/// <summary>
/// Updates the measure weight
/// </summary>
/// <param name="measure">Measure weight</param>
public void UpdateMeasureWeight(MeasureWeight measure)
{
_measureService.UpdateMeasureWeight(measure);
}
/// <summary>
/// Updates the measure weight
/// </summary>
/// <param name="measure">Measure weight</param>
public virtual void UpdateMeasureWeight(MeasureWeight measure)
{
_measureWeightRepository.Update(measure);
}
public static MeasureWeightModel ToModel(this MeasureWeight entity)
{
return(entity.MapTo <MeasureWeight, MeasureWeightModel>());
}
/// <summary>
/// Inserts a measure weight
/// </summary>
/// <param name="measure">Measure weight</param>
public virtual void InsertMeasureWeight(MeasureWeight measure)
{
_measureWeightRepository.Insert(measure);
}
/// <summary>
/// Deletes measure weight
/// </summary>
/// <param name="measureWeight">Measure weight</param>
public virtual void DeleteMeasureWeight(MeasureWeight measureWeight)
{
_measureWeightRepository.Delete(measureWeight);
}
/// <summary>
/// Converts to primary measure weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="sourceMeasureWeight">Source weight</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the converted value
/// </returns>
public virtual async Task <decimal> ConvertToPrimaryMeasureWeightAsync(decimal value, MeasureWeight sourceMeasureWeight)
{
if (sourceMeasureWeight == null)
{
throw new ArgumentNullException(nameof(sourceMeasureWeight));
}
var result = value;
var baseWeightIn = await GetMeasureWeightByIdAsync(_measureSettings.BaseWeightId);
if (result == decimal.Zero || sourceMeasureWeight.Id == baseWeightIn.Id)
{
return(result);
}
var exchangeRatio = sourceMeasureWeight.Ratio;
if (exchangeRatio == decimal.Zero)
{
throw new NopException($"Exchange ratio not set for weight [{sourceMeasureWeight.Name}]");
}
result = result / exchangeRatio;
return(result);
}
public void TestInitialize()
{
_measureDimensionInches = new MeasureDimension {
Id = "1",
Name = "inch(es)",
SystemKeyword = "inches",
Ratio = 1M,
DisplayOrder = 1,
};
_measureDimensionFeets = new MeasureDimension {
Id = "2",
Name = "feet",
SystemKeyword = "feet",
Ratio = 0.08333333M,
DisplayOrder = 2,
};
_measureDimensionMeters = new MeasureDimension {
Id = "3",
Name = "meter(s)",
SystemKeyword = "meters",
Ratio = 0.0254M,
DisplayOrder = 3,
};
_measureDimensionMilimeters = new MeasureDimension {
Id = "4",
Name = "millimetre(s)",
SystemKeyword = "millimetres",
Ratio = 25.4M,
DisplayOrder = 4,
};
_measureWeightOunces = new MeasureWeight {
Id = "1",
Name = "ounce(s)",
SystemKeyword = "ounce",
Ratio = 16M,
DisplayOrder = 1,
};
_measureWeightPounds = new MeasureWeight {
Id = "2",
Name = "lb(s)",
SystemKeyword = "lb",
Ratio = 1M,
DisplayOrder = 2,
};
_measureWeightKilograms = new MeasureWeight {
Id = "3",
Name = "kg(s)",
SystemKeyword = "kg",
Ratio = 0.45359237M,
DisplayOrder = 3,
};
_measureWeightGrams = new MeasureWeight {
Id = "4",
Name = "gram(s)",
SystemKeyword = "grams",
Ratio = 453.59237M,
DisplayOrder = 4,
};
var tempMeasureDimensionRepository = new Mock <IRepository <MeasureDimension> >();
{
var IMongoCollection = new Mock <IMongoCollection <MeasureDimension> >().Object;
IMongoCollection.InsertOne(_measureDimensionInches);
IMongoCollection.InsertOne(_measureDimensionFeets);
IMongoCollection.InsertOne(_measureDimensionMeters);
IMongoCollection.InsertOne(_measureDimensionMilimeters);
tempMeasureDimensionRepository.Setup(x => x.Table).Returns(IMongoCollection.AsQueryable());
tempMeasureDimensionRepository.Setup(x => x.GetById(_measureDimensionInches.Id)).Returns(_measureDimensionInches);
tempMeasureDimensionRepository.Setup(x => x.GetById(_measureDimensionFeets.Id)).Returns(_measureDimensionFeets);
tempMeasureDimensionRepository.Setup(x => x.GetById(_measureDimensionMeters.Id)).Returns(_measureDimensionMeters);
tempMeasureDimensionRepository.Setup(x => x.GetById(_measureDimensionMilimeters.Id)).Returns(_measureDimensionMilimeters);
_measureDimensionRepository = tempMeasureDimensionRepository.Object;
}
var tempMeasureWeightRepository = new Mock <IRepository <MeasureWeight> >();
{
var IMongoCollection = new Mock <IMongoCollection <MeasureWeight> >().Object;
IMongoCollection.InsertOne(_measureWeightOunces);
IMongoCollection.InsertOne(_measureWeightPounds);
IMongoCollection.InsertOne(_measureWeightKilograms);
IMongoCollection.InsertOne(_measureWeightGrams);
tempMeasureWeightRepository.Setup(x => x.Table).Returns(IMongoCollection.AsQueryable());
tempMeasureWeightRepository.Setup(x => x.GetById(_measureWeightOunces.Id)).Returns(_measureWeightOunces);
tempMeasureWeightRepository.Setup(x => x.GetById(_measureWeightPounds.Id)).Returns(_measureWeightPounds);
tempMeasureWeightRepository.Setup(x => x.GetById(_measureWeightKilograms.Id)).Returns(_measureWeightKilograms);
tempMeasureWeightRepository.Setup(x => x.GetById(_measureWeightGrams.Id)).Returns(_measureWeightGrams);
_measureWeightRepository = tempMeasureWeightRepository.Object;
}
_measureUnits = new MeasureUnit
{
Id = "1",
Name = "pcs.",
};
var tempMeasureUnitRepository = new Mock <IRepository <MeasureUnit> >();
{
var IMongoCollection = new Mock <IMongoCollection <MeasureUnit> >().Object;
IMongoCollection.InsertOne(_measureUnits);
tempMeasureUnitRepository.Setup(x => x.Table).Returns(IMongoCollection.AsQueryable());
tempMeasureUnitRepository.Setup(x => x.GetById(_measureUnits.Id)).Returns(_measureUnits);
_measureUnitRepository = tempMeasureUnitRepository.Object;
}
_measureSettings = new MeasureSettings();
_measureSettings.BaseDimensionId = _measureDimensionInches.Id; //inch(es) because all other dimensions are in relation to inches
_measureSettings.BaseWeightId = _measureWeightPounds.Id; //lb(s) because all other weights are in relation to pounds
var tempEventPublisher = new Mock <IEventPublisher>();
{
tempEventPublisher.Setup(x => x.Publish(It.IsAny <object>()));
_eventPublisher = tempEventPublisher.Object;
}
_measureService = new MeasureService(new TestMemoryCacheManager(new Mock <IMemoryCache>().Object), _measureDimensionRepository,
_measureWeightRepository, _measureUnitRepository, _measureSettings, _eventPublisher);
}
/// <summary>
/// Converts to primary measure weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="sourceMeasureWeight">Source weight</param>
/// <returns>Converted value</returns>
public decimal ConvertToPrimaryMeasureWeight(decimal value, MeasureWeight sourceMeasureWeight)
{
return(_measureService.ConvertToPrimaryMeasureWeight(value, sourceMeasureWeight));
}
/// <summary>
/// Converts weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="sourceMeasureWeight">Source weight</param>
/// <param name="targetMeasureWeight">Target weight</param>
/// <param name="round">A value indicating whether a result should be rounded</param>
/// <returns>Converted value</returns>
public virtual async Task <decimal> ConvertWeight(decimal value,
MeasureWeight sourceMeasureWeight, MeasureWeight targetMeasureWeight, bool round = true)
{
if (sourceMeasureWeight == null)
{
throw new ArgumentNullException("sourceMeasureWeight");
}
if (targetMeasureWeight == null)
{
throw new ArgumentNullException("targetMeasureWeight");
}
decimal result = value;
if (result != decimal.Zero && sourceMeasureWeight.Id != targetMeasureWeight.Id)
{
result = await ConvertToPrimaryMeasureWeight(result, sourceMeasureWeight);
result = await ConvertFromPrimaryMeasureWeight(result, targetMeasureWeight);
}
if (round)
{
result = Math.Round(result, 2);
}
return(result);
}
/// <summary>
/// Inserts a measure weight
/// </summary>
/// <param name="measure">Measure weight</param>
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task InsertMeasureWeightAsync(MeasureWeight measure)
{
await _measureWeightRepository.InsertAsync(measure);
}
public static MeasureWeight ToEntity(this MeasureWeightModel model, MeasureWeight destination)
{
return(model.MapTo(destination));
}
protected MeasureWeight Save()
{
MeasureWeight measureWeight = ctrlMeasureWeightInfo.SaveInfo();
return(measureWeight);
}
/// <summary>
/// Inserts a measure weight
/// </summary>
/// <param name="measure">Measure weight</param>
public void InsertMeasureWeight(MeasureWeight measure)
{
_measureService.InsertMeasureWeight(measure);
}
/// <summary>
/// Converts to primary measure weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="sourceMeasureWeight">Source weight</param>
/// <returns>Converted value</returns>
public virtual async Task <double> ConvertToPrimaryMeasureWeight(double value, MeasureWeight sourceMeasureWeight)
{
if (sourceMeasureWeight == null)
{
throw new ArgumentNullException(nameof(sourceMeasureWeight));
}
double result = value;
var baseWeightIn = await GetMeasureWeightById(_measureSettings.BaseWeightId);
if (result != 0 && sourceMeasureWeight.Id != baseWeightIn.Id)
{
double exchangeRatio = sourceMeasureWeight.Ratio;
if (exchangeRatio == 0)
{
throw new GrandException(string.Format("Exchange ratio not set for weight [{0}]", sourceMeasureWeight.Name));
}
result = result / exchangeRatio;
}
return(result);
}
/// <summary>
/// Converts weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="sourceMeasureWeight">Source weight</param>
/// <param name="targetMeasureWeight">Target weight</param>
/// <param name="round">A value indicating whether a result should be rounded</param>
/// <returns>Converted value</returns>
public decimal ConvertWeight(decimal value,
MeasureWeight sourceMeasureWeight, MeasureWeight targetMeasureWeight, bool round = true)
{
return(_measureService.ConvertWeight(value, sourceMeasureWeight, targetMeasureWeight, round));
}
public new void SetUp()
{
measureDimension1 = new MeasureDimension
{
Id = 1,
Name = "inch(es)",
SystemKeyword = "inches",
Ratio = 1M,
DisplayOrder = 1
};
measureDimension2 = new MeasureDimension
{
Id = 2,
Name = "feet",
SystemKeyword = "feet",
Ratio = 0.08333333M,
DisplayOrder = 2
};
measureDimension3 = new MeasureDimension
{
Id = 3,
Name = "meter(s)",
SystemKeyword = "meters",
Ratio = 0.0254M,
DisplayOrder = 3
};
measureDimension4 = new MeasureDimension
{
Id = 4,
Name = "millimetre(s)",
SystemKeyword = "millimetres",
Ratio = 25.4M,
DisplayOrder = 4
};
measureWeight1 = new MeasureWeight
{
Id = 1,
Name = "ounce(s)",
SystemKeyword = "ounce",
Ratio = 16M,
DisplayOrder = 1
};
measureWeight2 = new MeasureWeight
{
Id = 2,
Name = "lb(s)",
SystemKeyword = "lb",
Ratio = 1M,
DisplayOrder = 2
};
measureWeight3 = new MeasureWeight
{
Id = 3,
Name = "kg(s)",
SystemKeyword = "kg",
Ratio = 0.45359237M,
DisplayOrder = 3
};
measureWeight4 = new MeasureWeight
{
Id = 4,
Name = "gram(s)",
SystemKeyword = "grams",
Ratio = 453.59237M,
DisplayOrder = 4
};
_measureDimensionRepository = new Mock <IRepository <MeasureDimension> >();
_measureDimensionRepository.Setup(x => x.Table).Returns(new List <MeasureDimension> {
measureDimension1, measureDimension2, measureDimension3, measureDimension4
}.AsQueryable());
_measureDimensionRepository.Setup(x => x.GetById(measureDimension1.Id)).Returns(measureDimension1);
_measureDimensionRepository.Setup(x => x.GetById(measureDimension2.Id)).Returns(measureDimension2);
_measureDimensionRepository.Setup(x => x.GetById(measureDimension3.Id)).Returns(measureDimension3);
_measureDimensionRepository.Setup(x => x.GetById(measureDimension4.Id)).Returns(measureDimension4);
_measureWeightRepository = new Mock <IRepository <MeasureWeight> >();
_measureWeightRepository.Setup(x => x.Table).Returns(new List <MeasureWeight> {
measureWeight1, measureWeight2, measureWeight3, measureWeight4
}.AsQueryable());
_measureWeightRepository.Setup(x => x.GetById(measureWeight1.Id)).Returns(measureWeight1);
_measureWeightRepository.Setup(x => x.GetById(measureWeight2.Id)).Returns(measureWeight2);
_measureWeightRepository.Setup(x => x.GetById(measureWeight3.Id)).Returns(measureWeight3);
_measureWeightRepository.Setup(x => x.GetById(measureWeight4.Id)).Returns(measureWeight4);
var cacheManager = new TestMemoryCacheManager(new Mock <IMemoryCache>().Object);
_measureSettings = new MeasureSettings
{
BaseDimensionId = measureDimension1.Id, //inch(es)
BaseWeightId = measureWeight2.Id //lb(s)
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher.Setup(x => x.Publish(It.IsAny <object>()));
_measureService = new MeasureService(cacheManager,
_eventPublisher.Object,
_measureDimensionRepository.Object,
_measureWeightRepository.Object,
_measureSettings);
}
/// <summary>
/// Converts from primary weight
/// </summary>
/// <param name="value">Value to convert</param>
/// <param name="targetMeasureWeight">Target weight</param>
/// <returns>Converted value</returns>
public decimal ConvertFromPrimaryMeasureWeight(decimal value,
MeasureWeight targetMeasureWeight)
{
return(_measureService.ConvertFromPrimaryMeasureWeight(value, targetMeasureWeight));
}
public static MeasureWeight MakeClone(MeasureWeight another)
{
if (another == null) return null;
return another.MakeClone();
}
