public void combining_same_dimension()
{
var metre = MeasureUnit.Metre;
var decimetre = MeasureStandardPrefix.Deci[metre];
var centimetre = MeasureStandardPrefix.Centi[metre];
var r10 = metre.DivideBy(decimetre);
r10.Normalization.Should().Be(MeasureUnit.None);
r10.NormalizationFactor.Factor.Should().Be(1.0);
r10.NormalizationFactor.ExpFactor.Exp10.Should().Be(1);
r10.NormalizationFactor.ExpFactor.Exp2.Should().Be(0);
var inch = MeasureUnit.DefineAlias("in", "Inch", 2.54, centimetre);
var rInch = inch / centimetre;
rInch.Normalization.Should().Be(MeasureUnit.None);
rInch.NormalizationFactor.Factor.Should().Be(2.54);
rInch.NormalizationFactor.ExpFactor.Exp10.Should().Be(0);
rInch.NormalizationFactor.ExpFactor.Exp2.Should().Be(0);
}
internal static System.Drawing.GraphicsUnit xlat(MeasureUnit unit)
{
switch (unit)
{
case MeasureUnit.Display: return(System.Drawing.GraphicsUnit.Display);
case MeasureUnit.Document: return(System.Drawing.GraphicsUnit.Document);
case MeasureUnit.Inch: return(System.Drawing.GraphicsUnit.Inch);
case MeasureUnit.Millimeter: return(System.Drawing.GraphicsUnit.Millimeter);
case MeasureUnit.Pixel: return(System.Drawing.GraphicsUnit.Pixel);
case MeasureUnit.Point: return(System.Drawing.GraphicsUnit.Point);
case MeasureUnit.World: return(System.Drawing.GraphicsUnit.World);
default: return(System.Drawing.GraphicsUnit.World);
}
}
/// <summary>
/// Deletes measure unit
/// </summary>
/// <param name="measureUnit">Measure unit</param>
public virtual void DeleteMeasureUnit(MeasureUnit measureUnit)
{
if (measureUnit == null)
{
throw new ArgumentNullException("measureUnit");
}
var builder = Builders <Product> .Filter;
var filter = builder.Eq(x => x.UnitId, measureUnit.Id);
var update = Builders <Product> .Update
.Set(x => x.UnitId, "");
var result = Grand.Core.Infrastructure.EngineContext.Current.Resolve <IRepository <Product> >()
.Collection.UpdateManyAsync(filter, update).Result;
_measureUnitRepository.Delete(measureUnit);
_cacheManager.RemoveByPattern(MEASUREUNITS_PATTERN_KEY);
//event notification
_eventPublisher.EntityDeleted(measureUnit);
}
public void percent_or_other_dimensionless_units_are_convertible_into_each_other()
{
var percent = MeasureUnit.DefineAlias("%", "Percent", new ExpFactor(0, -2), MeasureUnit.None);
var pc10 = 10.WithUnit(percent);
pc10.ToString().Should().Be("10 %");
pc10.CanConvertTo(MeasureUnit.None).Should().Be(true, $"{percent.Name} should be convertible to {MeasureUnit.None.Name}");
var noDimension = pc10.ConvertTo(MeasureUnit.None);
noDimension.Unit.Should().Be(MeasureUnit.None);
noDimension.Value.Should().Be(0.01 * pc10.Value, $"is {pc10.ToString()}");
// Now, express the ratio in permille.
var permille = MeasureUnit.DefineAlias("‰", "Permille", new ExpFactor(0, -3), MeasureUnit.None);
noDimension.CanConvertTo(permille).Should().BeTrue();
var inPerMille = noDimension.ConvertTo(permille);
inPerMille.Unit.Should().Be(permille);
inPerMille.Value.Should().Be(10 * pc10.Value, $"is {pc10.ToString()}");
}
public void UserWork()
{
var userToken = GetUserToken();
var yandexToken = string.IsNullOrEmpty(userToken) ? DefaultSettings.DefaultToken : userToken;
_yandUploader = new YandexUploader(yandexToken);
var user = _yandUploader.GetUserInfo();
if (user?.User != null)
{
Console.WriteLine("Коннект к яндекс диску состоялся.");
Console.WriteLine($"Пользователь : {user.User.Display_Name} {user.User.Login}");
Console.WriteLine($"Общее место на диске (Гб) : {MeasureUnit.BytesToGigabytes(user.Total_Space)}");
Console.WriteLine($"Занятое место на диске (Гб): {MeasureUnit.BytesToGigabytes(user.Used_Space)}");
}
else
{
Console.Clear();
Console.WriteLine("Произошла ошибка при подключении к диску с указанным токеном.");
UserWork();
}
}
/// <summary>
/// Deletes measure unit
/// </summary>
/// <param name="measureUnit">Measure unit</param>
public virtual async Task DeleteMeasureUnit(MeasureUnit measureUnit)
{
if (measureUnit == null)
{
throw new ArgumentNullException("measureUnit");
}
var builder = Builders <Product> .Filter;
var filter = builder.Eq(x => x.UnitId, measureUnit.Id);
var update = Builders <Product> .Update
.Set(x => x.UnitId, "");
await _serviceProvider.GetRequiredService <IRepository <Product> >()
.Collection.UpdateManyAsync(filter, update);
await _measureUnitRepository.DeleteAsync(measureUnit);
_cacheManager.RemoveByPattern(MEASUREUNITS_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTS_PATTERN_KEY);
//event notification
await _eventPublisher.EntityDeleted(measureUnit);
}
public static double GetVelocitaTaglio(double numeroGiri, double diametro, MeasureUnit measureUnit, int decimalRound = 4)
{
switch (measureUnit)
{
case MeasureUnit.Millimeter:
{
var velocitaTaglio = (numeroGiri * diametro * Math.PI) / 1000;
return(Math.Round(velocitaTaglio, decimalRound));
}
break;
case MeasureUnit.Inch:
{
var velocitaTaglio = (numeroGiri * diametro * Math.PI * 1 / 12);
return(Math.Round(velocitaTaglio, decimalRound));
}
break;
}
throw new NotImplementedException();
}
public void TestSerializeMeasure()
{
ArrayList al = new ArrayList();
MeasureUnit mu = new MeasureUnit();
mu.NewCurrencyMeasure("TestCurrencyMeasure", "USD");
al.Add(mu);
MeasureUnit mu2 = new MeasureUnit();
mu2.NewComplexMeasure("Test2", CalculationTypeCode.Divide, new Measure("M1"), new Measure("m2"));
al.Add(mu2);
MeasureUnit mu3 = new MeasureUnit();
mu3.NewSharesMeasure("Shares");
al.Add(mu3);
MeasureUnit mu4 = new MeasureUnit();
mu4.NewSimpleMeasure("simple measure", new Measure("simple"));
al.Add(mu4);
MeasureUnit mu5 = new MeasureUnit();
mu5.NewPureMeasure("Pure");
al.Add(mu5);
MemoryStream ms = new MemoryStream();
XmlTextWriter tw = new XmlTextWriter(ms, Encoding.UTF8);
XmlSerializer xml = new XmlSerializer(typeof(ArrayList), new Type[] { typeof(MeasureUnit) });
xml.Serialize(tw, al);
}
/// <summary>
/// Deletes measure unit
/// </summary>
/// <param name="measureUnit">Measure unit</param>
public virtual async Task DeleteMeasureUnit(MeasureUnit measureUnit)
{
if (measureUnit == null)
{
throw new ArgumentNullException("measureUnit");
}
//remove unit from products
await _mediator.Send(new DeleteMeasureUnitOnProductCommand()
{
MeasureUnitId = measureUnit.Id
});
//delete
await _measureUnitRepository.DeleteAsync(measureUnit);
//clear cache
await _cacheManager.RemoveByPrefix(MEASUREUNITS_PATTERN_KEY);
await _cacheManager.RemoveByPrefix(PRODUCTS_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(measureUnit);
}
private static decimal GetGallonEquivalent(MeasureUnit toUnit)
{
decimal eq = 0;
switch (toUnit)
{
case MeasureUnit.LITER:
eq = 3.78541m;
break;
case MeasureUnit.MILLILITER:
eq = 3785.41m;
break;
case MeasureUnit.GALLON:
eq = 1;
break;
default:
break;
}
return(eq);
}
private static decimal GetLiterEquivalent(MeasureUnit toUnit)
{
decimal eq = 0;
switch (toUnit)
{
case MeasureUnit.LITER:
eq = 1;
break;
case MeasureUnit.MILLILITER:
eq = 1000;
break;
case MeasureUnit.GALLON:
eq = 0.264172m;
break;
default:
break;
}
return(eq);
}
private static decimal GetVolumeConversion(MeasureUnit fromUnit, MeasureUnit toUnit)
{
decimal eq = 0;
switch (fromUnit)
{
case MeasureUnit.LITER:
eq = GetLiterEquivalent(toUnit);
break;
case MeasureUnit.MILLILITER:
eq = GetMilliliterEquivalent(toUnit);
break;
case MeasureUnit.GALLON:
eq = GetGallonEquivalent(toUnit);
break;
default:
break;
}
return(eq);
}
private static decimal GetMilliliterEquivalent(MeasureUnit toUnit)
{
decimal eq = 0;
switch (toUnit)
{
case MeasureUnit.LITER:
eq = 0.001m;
break;
case MeasureUnit.MILLILITER:
eq = 1;
break;
case MeasureUnit.GALLON:
eq = 0.453592m;
break;
default:
break;
}
return(eq);
}
public virtual double CalculateDistance(IDistancePoint point1, IDistancePoint point2, MeasureUnit measureUnit)
{
throw new NotImplementedException();
}
static private MeasuresUnitFile ConvertToFile(MeasureUnit value)
{
return(new MeasuresUnitFile(value));
}
protected override async Task UpdateValueAsync(MeasureUnit value)
{
await this.viewModel.UpdateRadiusMeasureUnitAsync(value);
this.RefreshMeasureUnitAdapterData();
}
public MeasureUnit SaveMeasureUnit(MeasureUnit data)
{
try {
SetService(); return SerClient.SaveMeasureUnit(data); }
finally
{
SerClient.Close();
if (SerClient.State == CommunicationState.Faulted)
SerClient.Abort();
}
}
public static MeasureUnit ToEntity(this MeasureUnitModel model, MeasureUnit destination)
{
return(model.MapTo(destination));
}
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);
}
public Alesatore(MeasureUnit measureUnit)
: base(measureUnit)
{
ToolName = GuiRes.Reamer;
}
public string ProcessMeasureRequest(NameValueCollection queryString)
{
if (m_mapFunctionality == null) GetMeasureResource();
object o = Session["MeasureMapUnits"];
if (o != null)
m_mapUnits = (MapUnit)Enum.Parse(typeof(MapUnit), o.ToString());
else if (m_startMapUnits == MapUnit.Resource_Default)
m_mapUnits = GetResourceDefaultMapUnit();
else
m_mapUnits = m_startMapUnits;
string eventArg = queryString["EventArg"].ToLower();
string vectorAction = queryString["VectorAction"].ToLower();
string[] coordPairs, xys;
string coordString = queryString["coords"];
if (coordString == null && coordString.Length == 0)
coordString = "";
coordPairs = coordString.Split(char.Parse("|"));
string mapUnitString = queryString["MapUnits"];
if (mapUnitString != null && mapUnitString.Length > 0)
m_mapUnits = (MapUnit)Enum.Parse(typeof(MapUnit), mapUnitString);
Session["MeasureMapUnits"] = m_mapUnits;
string measureUnitString = queryString["MeasureUnits"];
if (measureUnitString != null && measureUnitString.Length > 0)
m_measureUnits = (MeasureUnit)Enum.Parse(typeof(MeasureUnit),measureUnitString);
string areaUnitstring = queryString["AreaUnits"];
if (areaUnitstring != null && areaUnitstring.Length > 0)
m_areaUnits = (AreaUnit)Enum.Parse(typeof(AreaUnit),areaUnitstring);
string response = "";
PointCollection points = new PointCollection();
PointCollection dPoints = new PointCollection();
ArrayList distances = new ArrayList();
double totalDistance = 0;
double segmentDistance = 0;
double area = 0;
double perimeter = 0;
double roundFactor = Math.Pow(10, m_numberDecimals);
double xD, yD, tempDist, tempDist2, tempArea, x1, x2, y1, y2;
TransformationParams transformationParameters = m_map.GetTransformationParams(TransformationDirection.ToMap);
if (vectorAction == "addpoint")
{
if (coordPairs != null && coordPairs.Length > 1)
{
for (int i = 0; i < coordPairs.Length; i++)
{
xys = coordPairs[i].Split(char.Parse(":"));
points.Add(Point.ToMapPoint(Convert.ToInt32(xys[0]), Convert.ToInt32(xys[1]), transformationParameters));
if (i > 0)
{
if (m_mapUnits == MapUnit.Degrees)
{
// use great circle formula
tempDist = DegreeToFeetDistance(points[i - 1].X, points[i - 1].Y, points[i].X, points[i].Y);
y1 = DegreeToFeetDistance(points[i].X, points[i].Y, points[i].X, 0);
x1 = DegreeToFeetDistance(points[i].X, points[i].Y, 0, points[i].Y);
dPoints.Add(new Point(x1, y1));
segmentDistance = ConvertUnits(tempDist, MapUnit.Feet, m_measureUnits);
}
else
{
// get third side of triangle for distance
xD = Math.Abs(points[i].X - points[i - 1].X);
yD = Math.Abs(points[i].Y - points[i - 1].Y);
tempDist = Math.Sqrt(Math.Pow(xD, 2) + Math.Pow(yD, 2));
segmentDistance = ConvertUnits(tempDist, m_mapUnits, m_measureUnits);
}
distances.Add(segmentDistance);
totalDistance += segmentDistance;
segmentDistance = Math.Round(segmentDistance * roundFactor) / roundFactor;
totalDistance = Math.Round(totalDistance * roundFactor) / roundFactor;
}
else
{
if (m_mapUnits == MapUnit.Degrees)
{
y1 = DegreeToFeetDistance(points[i].X, points[i].Y, points[i].X, 0);
x1 = DegreeToFeetDistance(points[i].X, points[i].Y, 0, points[i].Y);
dPoints.Add(new Point(x1, y1));
}
}
}
}
if (eventArg == "polygon")
{
if (points.Count > 2)
{
if (m_mapUnits == MapUnit.Degrees)
{
tempDist = DegreeToFeetDistance(points[points.Count - 1].X, points[points.Count - 1].Y, points[0].X, points[0].Y);
tempDist2 = ConvertUnits(tempDist, MapUnit.Feet, m_measureUnits);
distances.Add(tempDist2);
dPoints.Add(dPoints[0]);
}
else
{
xD = Math.Abs(points[points.Count - 1].X - points[0].X);
yD = Math.Abs(points[points.Count - 1].Y - points[0].Y);
tempDist = Math.Sqrt(Math.Pow(xD, 2) + Math.Pow(yD, 2));
tempDist2 = ConvertUnits(tempDist, m_mapUnits, m_measureUnits);
distances.Add(tempDist2);
}
points.Add(points[0]);
perimeter = totalDistance + tempDist2;
// add area calculation
tempArea = 0;
MapUnit mUnits = m_mapUnits;
for (int j = 0; j < points.Count - 1; j++)
{
if (m_mapUnits == MapUnit.Degrees)
{
x1 = Convert.ToDouble(dPoints[j].X);
x2 = Convert.ToDouble(dPoints[j + 1].X);
y1 = Convert.ToDouble(dPoints[j].Y);
y2 = Convert.ToDouble(dPoints[j + 1].Y);
mUnits = MapUnit.Feet;
}
else
{
x1 = Convert.ToDouble(points[j].X);
x2 = Convert.ToDouble(points[j + 1].X);
y1 = Convert.ToDouble(points[j].Y);
y2 = Convert.ToDouble(points[j + 1].Y);
}
//tempArea += tempArea + (x1 + x2) * (y1 - y2);
double xDiff = x2 - x1;
double yDiff = y2 - y1;
tempArea += x1 * yDiff - y1 * xDiff;
}
tempArea = Math.Abs(tempArea) / 2;
area = ConvertAreaUnits(tempArea, mUnits, m_areaUnits);
perimeter = Math.Round(perimeter * roundFactor) / roundFactor;
area = Math.Round(area * roundFactor) / roundFactor;
response = String.Format("<table cellspacing='0' ><tr><td>Perimeter: </td><td align='right'>{0}</td><td>{1}</td></tr><tr><td>Area:</td><td align='right'>{2}</td><td>{3}</td></tr></table>", perimeter, WriteMeasureUnitDropdown(), area, WriteAreaUnitDropdown());
}
else
response = String.Format("<table cellspacing='0' ><tr><td>Perimeter: </td><td align='right'> 0</td><td>{0}</td></tr><tr><td>Area:</td><td align='right'>0 </td><td>{1}</td></tr></table>", WriteMeasureUnitDropdown(), WriteAreaUnitDropdown());
}
else
response = String.Format("<table cellspacing='0' ><tr><td>Segment: </td><td align='right'>{0} </td><td>{1}</td></tr><tr><td>Total Length:</td><td align='right'>{2} </td><td>{3}</td></tr></table>", segmentDistance, m_measureUnits.ToString(), totalDistance, WriteMeasureUnitDropdown());
}
else if (vectorAction == "coordinates")
{
xys = coordPairs[0].Split(char.Parse(":"));
Point coordPoint = Point.ToMapPoint(Convert.ToInt32(xys[0]), Convert.ToInt32(xys[1]), transformationParameters);
response = String.Format("<table cellspacing='0' ><tr><td>X Coordinate:</td><td align='right'>{0}</td></tr><tr><td>Y Coordinate:</td><td align='right'>{1}</td></tr></table>", (Math.Round(coordPoint.X * roundFactor) / roundFactor).ToString(), (Math.Round(coordPoint.Y * roundFactor) / roundFactor).ToString());
}
else if (vectorAction == "finish")
{
response = "Shape complete";
}
return String.Format("measure:::{0}:::{1}:::{2}", m_id, vectorAction, response);
}
public Bareno(MeasureUnit measureUnit)
: base(measureUnit)
{
ToolName = GuiRes.Bore;
}
public double CalculateDistance(IDistancePoint point1, IDistancePoint point2, MeasureUnit measureUnit, DistanceCalculationMethod distanceMethod)
{
//Saves calculation when points are equivalent
if (point1.Equals(point2))
{
return(0);
}
else
{
return(_distanceMethods.FirstOrDefault(x => x.DistanceCalculationMethod == distanceMethod)?.CalculateDistance(point1, point2, measureUnit) ?? throw new ArgumentNullException(nameof(distanceMethod)));
}
}
public void Init()
{
// инициализация IoC
IoCInitializer.Init();
setting = new Setting()
{
UseReadyToAcceptStateForReturnFromClientWaybill = false
};
settingRepository = Mock.Get(IoCContainer.Resolve <ISettingRepository>());
settingRepository.Setup(x => x.Get()).Returns(setting);
storage = new Storage("qwe", StorageType.ExtraStorage)
{
Id = 42
};
accOrgSender = new Mock <AccountOrganization>();
accOrgSender.Setup(x => x.Id).Returns(1);
accOrgRecipient = new Mock <AccountOrganization>();
accOrgRecipient.Setup(x => x.Id).Returns(2);
valueAddedTax = new ValueAddedTax();
user = new Mock <User>();
user.Setup(x => x.GetPermissionDistributionType(It.IsAny <Permission>())).Returns(PermissionDistributionType.All);
createdBy = new Mock <User>();
createdBy.Setup(x => x.GetPermissionDistributionType(It.IsAny <Permission>())).Returns(PermissionDistributionType.All);
acceptedBy = new Mock <User>();
acceptedBy.Setup(x => x.GetPermissionDistributionType(It.IsAny <Permission>())).Returns(PermissionDistributionType.All);
receiptedBy = new Mock <User>();
receiptedBy.Setup(x => x.GetPermissionDistributionType(It.IsAny <Permission>())).Returns(PermissionDistributionType.All);
var articleGroup = new ArticleGroup("Тестовая группа", "Тестовая группа");
var measureUnit = new MeasureUnit("шт.", "Штука", "123", 0)
{
Id = 1
};
articleA = new Article("Тестовый товар A", articleGroup, measureUnit, true)
{
Id = 1
};
articleB = new Article("Тестовый товар Б", articleGroup, measureUnit, true)
{
Id = 2
};
receiptWaybillRow1 = new Mock <ReceiptWaybillRow>();
receiptWaybillRow1.Setup(x => x.Article).Returns(articleA);
receiptWaybillRow2 = new Mock <ReceiptWaybillRow>();
receiptWaybillRow2.Setup(x => x.Article).Returns(articleB);
articleAccountingPrice = new List <ArticleAccountingPrice>()
{
new ArticleAccountingPrice(articleA, 100)
};
returnFromClientWaybillRepository = Mock.Get(IoCContainer.Resolve <IReturnFromClientWaybillRepository>());
articlePriceService = Mock.Get(IoCContainer.Resolve <IArticlePriceService>());
articlePriceService.Setup(x => x.GetArticleAccountingPrices(It.Is <short>(y => y == storage.Id), It.IsAny <IEnumerable <int> >())).Returns(articleAccountingPrice);
articlePriceService.Setup(x => x.GetArticleAccountingPrices(It.Is <short>(y => y == storage.Id), It.IsAny <ISubQuery>(), It.IsAny <DateTime>())).Returns(articleAccountingPrice);
returnFromClientWaybillRepository = Mock.Get(IoCContainer.Resolve <IReturnFromClientWaybillRepository>());
expenditureWaybillIndicatorService = Mock.Get(IoCContainer.Resolve <IExpenditureWaybillIndicatorService>());
articleAvailabilityService = Mock.Get(IoCContainer.Resolve <IArticleAvailabilityService>());
returnFromClientWaybillService = new ReturnFromClientWaybillService(
IoCContainer.Resolve <ISettingRepository>(),
returnFromClientWaybillRepository.Object,
IoCContainer.Resolve <ITeamRepository>(),
IoCContainer.Resolve <IDealRepository>(),
IoCContainer.Resolve <IStorageRepository>(),
IoCContainer.Resolve <IUserRepository>(),
IoCContainer.Resolve <IArticlePriceService>(),
IoCContainer.Resolve <IAcceptedSaleIndicatorService>(),
IoCContainer.Resolve <IReturnFromClientService>(),
IoCContainer.Resolve <IFactualFinancialArticleMovementService>(),
IoCContainer.Resolve <IArticleMovementOperationCountService>(),
IoCContainer.Resolve <IArticleMovementService>(),
IoCContainer.Resolve <IDealPaymentDocumentDistributionService>(),
IoCContainer.Resolve <IDealIndicatorService>(),
IoCContainer.Resolve <IArticleRevaluationService>(),
expenditureWaybillIndicatorService.Object,
articleAvailabilityService.Object
);
deal = new Mock <Deal>();
quota = new DealQuota("asd", 10, 45, 15000);
team = new Team("Тестовая команда", It.IsAny <User>())
{
Id = 1
};
contract = new Mock <ClientContract>();
var economicAgent = new Mock <EconomicAgent>();
accountOrganization = new AccountOrganization("asd", "asd", economicAgent.Object);
deal.Setup(x => x.IsActive).Returns(true);
deal.Setup(x => x.IsClosed).Returns(false);
deal.Setup(x => x.Quotas).Returns(new List <DealQuota> {
quota
});
deal.Setup(x => x.Contract).Returns(contract.Object);
accountOrganization.AddStorage(storage);
contract.Setup(x => x.AccountOrganization).Returns(accountOrganization);
returnFromClientWaybill = new ReturnFromClientWaybill("123", DateTime.Now, accountOrganization, deal.Object, team, storage, new ReturnFromClientReason(), user.Object, createdBy.Object, DateTime.Now);
sale = new Mock <ExpenditureWaybill>();
sale.Setup(x => x.Sender).Returns(accountOrganization);
sale.Setup(x => x.Team).Returns(team);
sale.Setup(x => x.Is <ExpenditureWaybill>()).Returns(true);
sale.Setup(x => x.As <ExpenditureWaybill>()).Returns(sale.Object);
#region Создание позиции 1
saleRow1 = new Mock <ExpenditureWaybillRow>();
saleRow1.Setup(x => x.ExpenditureWaybill).Returns(sale.Object);
saleRow1.Setup(x => x.SaleWaybill).Returns(sale.Object);
saleRow1.Setup(x => x.Id).Returns(Guid.NewGuid());
saleRow1.Setup(x => x.SellingCount).Returns(100);
saleRow1.Setup(x => x.As <ExpenditureWaybillRow>()).Returns(saleRow1.Object);
saleRow1.Setup(x => x.Is <ExpenditureWaybillRow>()).Returns(true);
saleRow1.Setup(x => x.Article).Returns(articleA);
saleRow1.Setup(x => x.SalePrice).Returns(128);
saleRow1.Setup(x => x.ReceiptWaybillRow).Returns(receiptWaybillRow1.Object);
#endregion
#region Создание позиции 2
saleRow2 = new Mock <ExpenditureWaybillRow>();
saleRow2.Setup(x => x.ExpenditureWaybill).Returns(sale.Object);
saleRow2.Setup(x => x.SaleWaybill).Returns(sale.Object);
saleRow2.Setup(x => x.Id).Returns(Guid.NewGuid());
saleRow2.Setup(x => x.SellingCount).Returns(100);
saleRow2.Setup(x => x.As <ExpenditureWaybillRow>()).Returns(saleRow2.Object);
saleRow2.Setup(x => x.Is <ExpenditureWaybillRow>()).Returns(true);
saleRow2.Setup(x => x.Article).Returns(articleA);
saleRow2.Setup(x => x.SalePrice).Returns(128);
saleRow2.Setup(x => x.ReceiptWaybillRow).Returns(receiptWaybillRow2.Object);
#endregion
ReturnFromClientWaybillRow row = new ReturnFromClientWaybillRow(saleRow1.Object, 1);
returnFromClientWaybill.AddRow(row);
articleMovementService = new Mock <IArticleMovementService>();
articleMovementService.Setup(x => x.CancelArticleAcceptance(It.IsAny <WriteoffWaybill>()))
.Returns(new List <OutgoingWaybillRowSourceReservationInfo>()
{
new OutgoingWaybillRowSourceReservationInfo(row.Id, 1, 1)
});
articleMovementService.Setup(x => x.AcceptArticles(It.IsAny <WriteoffWaybill>()))
.Returns(new List <OutgoingWaybillRowSourceReservationInfo>()
{
new OutgoingWaybillRowSourceReservationInfo(row.Id, 1, 1)
});
}
protected override Task UpdateValueAsync(MeasureUnit value)
{
this.viewModel.SetMarginUnit(value);
this.RefreshMeasureUnitAdapterData();
return(Task.CompletedTask);
}
public void Delete(MeasureUnit measureUnit, User user)
{
CheckPossibilityToDelete(measureUnit, user);
measureUnitRepository.Delete(measureUnit);
}
internal static Utensile CreateTool(LavorazioniEnumOperazioni enumOperationType, MeasureUnit unit)
{
switch (enumOperationType)
{
case LavorazioniEnumOperazioni.TornituraScanalaturaSgrossatura:
case LavorazioniEnumOperazioni.TornituraScanalaturaFinitura:
return(new UtensileScanalatura(unit));
case LavorazioniEnumOperazioni.FresaturaSpianaturaFinitura:
case LavorazioniEnumOperazioni.FresaturaSpianaturaSgrossatura:
return(new FresaSpianare(unit));
case LavorazioniEnumOperazioni.AllargaturaBareno:
case LavorazioniEnumOperazioni.Sgrossatura:
case LavorazioniEnumOperazioni.Finitura:
case LavorazioniEnumOperazioni.FresaturaFilettare:
return(new FresaCandela(unit));
case LavorazioniEnumOperazioni.ForaturaCentrino:
return(new Centrino(unit));
case LavorazioniEnumOperazioni.ForaturaPunta:
return(new Punta(unit));
case LavorazioniEnumOperazioni.Smussatura:
case LavorazioniEnumOperazioni.ForaturaSmusso:
return(new Svasatore(unit));
case LavorazioniEnumOperazioni.ForaturaMaschiaturaDx:
return(new Maschio(unit));
case LavorazioniEnumOperazioni.ForaturaBareno:
return(new Bareno(unit));
case LavorazioniEnumOperazioni.ForaturaAlesatore:
return(new Alesatore(unit));
case LavorazioniEnumOperazioni.ForaturaLamatore:
return(new Lamatore(unit));
case LavorazioniEnumOperazioni.TornituraSgrossatura:
case LavorazioniEnumOperazioni.TornituraFinitura:
case LavorazioniEnumOperazioni.TornituraSfacciaturaSgrossatura:
case LavorazioniEnumOperazioni.TornituraSfacciaturaFinitura:
return(new UtensileTornitura(unit));
case LavorazioniEnumOperazioni.TornituraFilettatura:
return(new UtensileFilettare(unit));
}
throw new NotImplementedException();
}
public Vector3D Convert(MeasureUnit from, MeasureUnit to)
{
return(new Vector3D(X.Convert(from, to), Y.Convert(from, to), Z.Convert(from, to)));
}
public double ConvertUnits(double distance, MapUnit fromUnits, MeasureUnit toUnits)
{
double mDistance = distance;
if (fromUnits == MapUnit.Feet)
{
if (toUnits == MeasureUnit.Miles)
{
mDistance = distance / 5280;
}
else if (toUnits == MeasureUnit.Meters)
{
mDistance = distance * 0.304800609601;
}
else if (toUnits == MeasureUnit.Kilometers)
{
mDistance = distance * 0.0003048;
}
}
else
{
if (toUnits == MeasureUnit.Miles)
{
mDistance = distance * 0.0006213700922;
}
else if (toUnits == MeasureUnit.Feet)
{
mDistance = distance * 3.280839895;
}
else if (toUnits == MeasureUnit.Kilometers)
{
mDistance = distance / 1000;
}
}
return mDistance;
}
public UtensileScanalatura(MeasureUnit measureUnit) :
base(measureUnit)
{
ToolName = GuiRes.TurnGroove;
}
internal NetFont(string name, float size, FontStyling style, MeasureUnit unit)
{
m_Font = new Font(name, size, xlator.xlat(style), xlator.xlat(unit));
}
public UtensileFilettare(MeasureUnit measureUnit) :
base(measureUnit)
{
ToolName = GuiRes.TurnThread;
}
public static MeasureUnitModel ToModel(this MeasureUnit entity)
{
return(entity.MapTo <MeasureUnit, MeasureUnitModel>());
}
public void DeleteMeasureUnit(MeasureUnit data)
{
try {
SetService(); SerClient.DeleteMeasureUnit(data); }
finally
{
SerClient.Close();
if (SerClient.State == CommunicationState.Faulted)
SerClient.Abort();
}
}
