/// <summary>
/// Converts from this unit of measure to a different unit of measure.
/// </summary>
public static double ConvertTo(this UnitOfMeasure sourceUnitOfMeasure, double amount, int precision, UnitOfMeasure finalUnitOfMeasure)
{
// If we happen to be the Unit of Measure being requested, return that.
if (finalUnitOfMeasure == sourceUnitOfMeasure)
return amount;
// If the Type of the Unit of Measure differs between the Source and the Destination, we need to throw an error.
if (sourceUnitOfMeasure.GetUnitOfMeasureType() != finalUnitOfMeasure.GetUnitOfMeasureType())
{
throw new InvalidCastException(String.Format("Unit of measures are not of same measurement type: {0} and {1}",
sourceUnitOfMeasure.GetUnitOfMeasureType(), finalUnitOfMeasure.GetUnitOfMeasureType()));
}
// Calculate Source to Primary Unit of Measure
// seconds = (60 * (x minutes))
// ºK = (0.5555555556 * (ºF - 32)) + 273.15
double primaryUnitOfMeasureValue =
(sourceUnitOfMeasure.GetMultiplier() * (amount + sourceUnitOfMeasure.GetPreCalcAddition())) +
sourceUnitOfMeasure.GetPostCalcAddition();
// Here is where we do the conversion from the Primary Unit of Measure to the Requested Destination Measure. Some examples include.
// minutes = ((x seconds - 0) / 60) - 0
// ºF = ((ºK - 273.15) / 0.5555555556) + 32.00
double calculation =
((primaryUnitOfMeasureValue - finalUnitOfMeasure.GetPostCalcAddition()) / finalUnitOfMeasure.GetMultiplier()) -
finalUnitOfMeasure.GetPreCalcAddition();
// Return the calculation rounded to the precision requested.
return Math.Round(calculation, precision);
}
public static decimal ConvertLengthToMeters(decimal quantity, UnitOfMeasure sourceUnit)
{
if (!ToMeters.ContainsKey(sourceUnit))
{
throw new ArgumentException("Invalid conversion type", "sourceUnit");
}
return ToMeters[sourceUnit] * quantity;
}
public static decimal ConvertLengthFromMeters(decimal quantity, UnitOfMeasure targetUnit)
{
if (!FromMeters.ContainsKey(targetUnit))
{
throw new ArgumentException("Invalid conversion type", "targetUnit");
}
return FromMeters[targetUnit] * quantity;
}
public IDisplayUnits Get(string tag, UnitOfMeasure targetUnit, UnitPlurality plurality) {
if (String.IsNullOrEmpty(tag))
if (!_defaults.Any(kv => kv.Key.IsAssignableFrom(targetUnit.GetType())))
throw new InvalidOperationException("No tag was provided and no default is available for type {0}".Use(targetUnit));
else
return _defaults.First(kv => kv.Key.IsAssignableFrom(targetUnit.GetType())).Value;
else
return GetByTag(tag);
}
public string AddUnit(string name = "", string code = "")
{
CurtDevDataContext db = new CurtDevDataContext();
UnitOfMeasure unit = new UnitOfMeasure();
UnitOfMeasure exists = db.UnitOfMeasures.Where(x => x.name.Equals(name) || x.code.Equals(code)).FirstOrDefault<UnitOfMeasure>();
if (exists == null) {
unit = new UnitOfMeasure {
name = name,
code = code
};
db.UnitOfMeasures.InsertOnSubmit(unit);
db.SubmitChanges();
}
return JsonConvert.SerializeObject(unit);
}
public IEnumerable<UnitOfMeasureComponent> GetComponents(UnitOfMeasure unitOfMeasure, int power)
{
var components = new List<UnitOfMeasureComponent>();
var compositeUnitOfMeasure = unitOfMeasure as CompositeUnitOfMeasure;
if (compositeUnitOfMeasure == null)
{
components.Add(new UnitOfMeasureComponent(unitOfMeasure, power));
return components;
}
foreach (var component in compositeUnitOfMeasure.Components)
components.AddRange(GetComponents(component.Unit, component.Power * power));
return components;
}
public void DeleteUnitOfMeasureByUnitOfMeasurreID(UnitOfMeasureInfo UOMInfo)
{
try
{
using (RMSDataContext db = new RMSDataContext())
{
var obj = (from a in db.UnitOfMeasures where a.UMID == UOMInfo.UMID select a).First();
db.UnitOfMeasures.DeleteOnSubmit(obj);
db.SubmitChanges();
}
}
catch (Exception ex)
{
UnitOfMeasure tbl = new UnitOfMeasure();
}
}
public void TestBridgeUnits3()
{
UnitOfMeasure uomGrams = sys.GetUOM(Unit.GRAM);
UnitOfMeasure uomTonnes = sys.GetUOM(Unit.TONNE);
UnitOfMeasure uomShortTons = sys.GetUOM(Unit.US_TON);
UnitOfMeasure uomTroyOz = sys.GetUOM(Unit.TROY_OUNCE);
UnitOfMeasure uomPennyweight = sys.CreateScalarUOM(UnitType.MASS, "pennyweight", "dwt", "Pennyweight");
uomPennyweight.SetConversion(0.05, uomTroyOz);
UnitOfMeasure uomGramsPerTonne = sys.CreateQuotientUOM(uomGrams, uomTonnes);
UnitOfMeasure uomPennyweightPerShortTon = sys.CreateQuotientUOM(uomPennyweight, uomShortTons);
Quantity grade = new Quantity(0.95, uomGramsPerTonne);
Quantity converted = grade.Convert(uomPennyweightPerShortTon);
Assert.IsTrue(IsCloseTo(converted.Amount, 0.554167, DELTA6));
}
public async Task <IActionResult> GetUnitOfMeasureById(int Id)
{
UnitOfMeasure Items = new UnitOfMeasure();
try
{
Items = await _context.UnitOfMeasure.Where(q => q.UnitOfMeasureId.Equals(Id)).FirstOrDefaultAsync();
}
catch (Exception ex)
{
_logger.LogError($"Ocurrio un error: { ex.ToString() }");
return(BadRequest($"Ocurrio un error:{ex.Message}"));
}
return(await Task.Run(() => Ok(Items)));
}
public Customer_UnitOfMeasureDTO(UnitOfMeasure UnitOfMeasure)
{
this.Id = UnitOfMeasure.Id;
this.Code = UnitOfMeasure.Code;
this.Name = UnitOfMeasure.Name;
this.Description = UnitOfMeasure.Description;
this.StatusId = UnitOfMeasure.StatusId;
this.Used = UnitOfMeasure.Used;
this.Errors = UnitOfMeasure.Errors;
}
public static async Task Run(GeotabDataOnlyPlanAPI api)
{
ConsoleUtility.LogExampleStarted(typeof(GetUnitOfMeasureAsyncExample).Name);
try
{
string unitOfMeasureId = KnownId.UnitOfMeasureKilometersPerHourId.ToString();
UnitOfMeasure unitOfMeasure = await api.GetUnitOfMeasureAsync(unitOfMeasureId);
}
catch (Exception ex)
{
ConsoleUtility.LogError(ex);
}
ConsoleUtility.LogExampleFinished(typeof(GetUnitOfMeasureAsyncExample).Name);
}
/// <summary>
///
/// </summary>
/// <param name="currency"></param>
/// <returns></returns>
public bool DeleteUnitOfMeasure(Guid id)
{
bool isDeleted = false;
using (var dbContext = new SCMSEntities())
{
UnitOfMeasure unitOfMeasure = dbContext.UnitOfMeasures.Single(c => c.Id.Equals(id));
dbContext.UnitOfMeasures.Remove(unitOfMeasure);
if (dbContext.SaveChanges() > 0)
{
isDeleted = true;
ClearUnitOfMeasureSessionData();
}
}
return(isDeleted);
}
public void TestEpsgCodeUom()
{
if (!File.Exists(EpsgAccessDatabase))
{
throw new IgnoreException("Epsg Access Database not found");
}
var connectionString = $"Provider=Microsoft.Jet.OLEDB.4.0; Data Source={EpsgAccessDatabase};";
using (var connection = new System.Data.OleDb.OleDbConnection(connectionString))
{
connection.Open();
var cmd = connection.CreateCommand();
cmd.CommandText = SqlEpsgToUom;
var uomr = new CrsUnitOfMeasureRegistry();
using (var dr = cmd.ExecuteReader())
{
if (dr != null)
{
while (dr.Read())
{
if ((int)dr[0] > 32768)
{
break;
}
CrsIdentifier crs;
if (CrsIdentifier.TryParse(string.Format("urn:ogc:def:crs:EPSG::{0}", dr.GetInt32(0)), out crs))
{
var uom = new UnitOfMeasure();
Assert.DoesNotThrow(() => uom = uomr[crs], "Getting unit of measure failed for {0}", crs);
var uomCode = dr.GetInt32(1);
if (uomCode == 9001 || uomCode == 1024)
{
Assert.AreEqual(1d, uom.ToMeter, "Unit of measure ToMeter is not 1d: {0}", crs);
}
else
{
Assert.AreNotEqual(1d, uom.ToMeter, "Unit of measure ToMeter should not be 1d: {0}", crs);
}
}
}
}
}
}
}
public void Api_UnitOfMeasureController_AssignUOMsToProductCategories()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
User u = TestHelper.GenerateTestUser(Guid.NewGuid().ToString("N"));
u.SiteAdmin = true;
List <UnitOfMeasure> uoms = new List <UnitOfMeasure>();
UnitOfMeasure mdl = new UnitOfMeasure();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.UUID = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.UtcNow;
uoms.Add(mdl);
UnitOfMeasure mdl2 = new UnitOfMeasure();
mdl2.AccountUUID = SystemFlag.Default.Account;
mdl2.Name = Guid.NewGuid().ToString("N");
mdl2.DateCreated = DateTime.UtcNow;
uoms.Add(mdl2);
string postData = JsonConvert.SerializeObject(uoms);
SessionManager sessionManager = new SessionManager(connectionKey);
string userJson = JsonConvert.SerializeObject(u);
UserSession us = sessionManager.SaveSession("127.1.1.35", u.UUID, userJson, false);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/UnitsOfMeasure/ProductCategories/Assign", postData, us.AuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
UnitOfMeasure dbUnitOfMeasure = context.GetAll <UnitOfMeasure>().Where(w => w.Name == mdl.Name).FirstOrDefault();
Assert.IsNotNull(dbUnitOfMeasure);
Assert.AreEqual(u.UUID, dbUnitOfMeasure.CreatedBy);
dbUnitOfMeasure = context.GetAll <UnitOfMeasure>().Where(w => w.Name == mdl2.Name).FirstOrDefault();
Assert.IsNotNull(dbUnitOfMeasure);
Assert.AreEqual(u.UUID, dbUnitOfMeasure.CreatedBy);
}).GetAwaiter().GetResult();
}
private SvgUnit GetRelativeUnit(double value, SvgUnitType type)
{
if (type == SvgUnitType.Pixel)
{
var convertedValue = (PreciseDouble)value * PixelToCm;
convertedValue = UnitOfMeasure.ConvertTo(convertedValue, UnitOfMeasure.Cm, Options.ExportUnit);
return new SvgUnit((float)convertedValue);
}
else if (type == SvgUnitType.Point)
{
var convertedValue = (PreciseDouble)value * PointToCm;
convertedValue = UnitOfMeasure.ConvertTo(convertedValue, UnitOfMeasure.Cm, Options.ExportUnit);
return new SvgUnit((float)convertedValue);
}
return new SvgUnit(type, (float)value);
}
public double GetDefault(UnitOfMeasure unit)
{
switch (unit)
{
case UnitOfMeasure.meter:
return(0.1);
case UnitOfMeasure.centimeter:
return(10);
case UnitOfMeasure.milimeter:
return(100);
default:
throw new ArgumentException();
}
}
public void TestUSQuantity()
{
UnitOfMeasure gal = sys.GetUOM(Unit.US_GALLON);
UnitOfMeasure in3 = sys.GetUOM(Unit.CUBIC_INCH);
UnitOfMeasure floz = sys.GetUOM(Unit.US_FLUID_OUNCE);
UnitOfMeasure qt = sys.GetUOM(Unit.US_QUART);
Quantity q1 = new Quantity(10, gal);
Quantity q2 = q1.Convert(in3);
Assert.IsTrue(IsCloseTo(q2.Amount, 2310, DELTA6));
Assert.IsTrue(q2.UOM.Equals(in3));
q1 = new Quantity(128, floz);
q2 = q1.Convert(qt);
Assert.IsTrue(IsCloseTo(q2.Amount, 4, DELTA6));
Assert.IsTrue(q2.UOM.Equals(qt));
UnitOfMeasure ft = sys.GetUOM(Unit.FOOT);
UnitOfMeasure inch = sys.GetUOM(Unit.INCH);
UnitOfMeasure mi = sys.GetUOM(Unit.MILE);
q1 = new Quantity(10, ft);
q2 = q1.Convert(inch);
q1 = new Quantity(1, mi);
// British cup to US gallon
q1 = new Quantity(10, sys.GetUOM(Unit.BR_CUP));
q2 = q1.Convert(sys.GetUOM(Unit.US_GALLON));
Assert.IsTrue(IsCloseTo(q2.Amount, 0.6, DELTA3));
// US ton to British ton
q1 = new Quantity(10, sys.GetUOM(Unit.US_TON));
q2 = q1.Convert(sys.GetUOM(Unit.BR_TON));
Assert.IsTrue(IsCloseTo(q2.Amount, 8.928571428, DELTA6));
// troy ounce to ounce
q1 = new Quantity(10, Unit.TROY_OUNCE);
Assert.IsTrue(IsCloseTo(q1.Convert(Unit.OUNCE).Amount, 10.971, DELTA3));
// deci-litre to quart
q1 = new Quantity(10, Prefix.DECI, Unit.LITRE);
q2 = q1.Convert(Unit.US_QUART);
Assert.IsTrue(IsCloseTo(q2.Amount, 1.0566882, DELTA6));
}
public static string GetUnitFriendlyName(UnitOfMeasure m)
{
switch (m)
{
case UnitOfMeasure.milimeter:
return("mm");
case UnitOfMeasure.centimeter:
return("cm");
case UnitOfMeasure.meter:
return("m");
default:
throw new ArgumentException("Not defined unit");
}
}
////////////////////////////////////////////////////////////////////
// Constructor
// Default page size is Width and Height in user unit of measure
// Default page orientation is portrait if Height > Width landscape if Height < Width
// Unit of measure is: Point, Inch, cm, mm
////////////////////////////////////////////////////////////////////
public PdfDocument
(
Double Width, // page width
Double Height, // page height
UnitOfMeasure UnitOfMeasure // unit of measure: Point, Inch, cm, mm
) : this()
{
// set scale factor (user units to points)
ScaleFactor = UnitInPoints[(Int32)UnitOfMeasure];
// save page default size
this.PageSize.Width = Width * ScaleFactor;
this.PageSize.Height = Height * ScaleFactor;
// exit
return;
}
protected override void Seed(Context context)
{
var unit1 = new UnitOfMeasure {
Name = Resource.art
};
var unit2 = new UnitOfMeasure {
Name = Resource.runningMeter
};
var unit3 = new UnitOfMeasure {
Name = Resource.squareMeter
};
var unit4 = new UnitOfMeasure {
Name = Resource.kilogram
};
var unit5 = new UnitOfMeasure {
Name = Resource.cubicMeter
};
context.UnitsOfMeasure.Add(unit1);
context.UnitsOfMeasure.Add(unit2);
context.UnitsOfMeasure.Add(unit3);
context.UnitsOfMeasure.Add(unit4);
context.UnitsOfMeasure.Add(unit5);
var currency1 = new Currency {
Code = "PLN"
};
var currency2 = new Currency {
Code = "EUR"
};
context.Currencies.Add(currency1);
context.Currencies.Add(currency2);
var paymentMethod1 = new PaymentMethod {
Name = Resource.transferMethod
};
var paymentMethod2 = new PaymentMethod {
Name = Resource.cashMethod
};
context.PaymentMethods.Add(paymentMethod1);
context.PaymentMethods.Add(paymentMethod2);
context.SaveChanges();
}
/// <summary>
///
/// </summary>
/// <param name="currency"></param>
/// <returns></returns>
public bool EditUnitOfMeasure(UnitOfMeasure unitOfMeasure)
{
bool isSaved = false;
using (var context = new SCMSEntities())
{
context.UnitOfMeasures.Attach(unitOfMeasure);
((IObjectContextAdapter)context).ObjectContext.ObjectStateManager.ChangeObjectState(unitOfMeasure, System.Data.EntityState.Modified);
if (context.SaveChanges() > 0)
{
isSaved = true;
ClearUnitOfMeasureSessionData();
}
}
return(isSaved);
}
public async Task <ActionResult <UnitOfMeasure> > Insert([FromBody] UnitOfMeasure payload)
{
UnitOfMeasure unitOfMeasure = payload;
try
{
_context.UnitOfMeasure.Add(unitOfMeasure);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
_logger.LogError($"Ocurrio un error: { ex.ToString() }");
return(BadRequest($"Ocurrio un error:{ex.Message}"));
}
return(await Task.Run(() => Ok(unitOfMeasure)));
}
public Pudelko(double a, double b, UnitOfMeasure unit = UnitOfMeasure.meter)
{
if (unit == UnitOfMeasure.meter)
{
if (a <= 0 || b <= 0)
{
throw new ArgumentOutOfRangeException();
}
if (a > 10 || b > 10)
{
throw new ArgumentOutOfRangeException();
}
A = a;
B = b;
C = 0.1;
}
else if (unit == UnitOfMeasure.centimeter)
{
if (a <= 0.01 || b <= 0.01)
{
throw new ArgumentOutOfRangeException();
}
if (a > 1000 || b > 1000)
{
throw new ArgumentOutOfRangeException();
}
A = a / 100;
B = b / 100;
C = 0.1;
}
else if (unit == UnitOfMeasure.milimeter)
{
if (a <= 1 || b <= 1)
{
throw new ArgumentOutOfRangeException();
}
if (a > 10000 || b > 10000)
{
throw new ArgumentOutOfRangeException();
}
A = a / 1000;
B = b / 1000;
C = 0.1;
}
}
public async Task <ActionResult> pvwModalUnidad([FromBody] UnitOfMeasure _unidad)
{
UnitOfMeasure _UnitOfMeasure = new UnitOfMeasure();
try
{
string baseadress = _config.Value.urlbase;
HttpClient _client = new HttpClient();
_client.DefaultRequestHeaders.Add("Authorization", "Bearer " + HttpContext.Session.GetString("token"));
var result = await _client.GetAsync(baseadress + "api/UnitOfMeasure/GetUnitOfMeasureById/" + _unidad.UnitOfMeasureId);
string valorrespuesta = "";
if (result.IsSuccessStatusCode)
{
valorrespuesta = await(result.Content.ReadAsStringAsync());
_UnitOfMeasure = JsonConvert.DeserializeObject <UnitOfMeasure>(valorrespuesta);
//
//Obtener los estados. (Activo/Inactivo)
var result2 = await _client.GetAsync(baseadress + "api/Estados/GetEstadosByGrupo/" + 1);
if (result2.IsSuccessStatusCode)
{
valorrespuesta = await(result2.Content.ReadAsStringAsync());
var estados = JsonConvert.DeserializeObject <List <Estados> >(valorrespuesta);
if (_UnitOfMeasure == null)
{
ViewData["estados"] = new SelectList(estados, "IdEstado", "NombreEstado");
_UnitOfMeasure = new UnitOfMeasure();
}
else
{
ViewData["estados"] = new SelectList(estados, "IdEstado", "NombreEstado", _UnitOfMeasure.IdEstado);
//ViewData["estadoUnidad"] = _UnitOfMeasure.IdEstado;
}
}
}
}
catch (Exception ex)
{
_logger.LogError($"Ocurrio un error: { ex.ToString() }");
throw ex;
}
return(PartialView(_UnitOfMeasure));
}
private static List <Resource> Resources(UnitOfMeasure pieceUnit) => new List <Resource>
{
new Resource
{
Name = "Handschuhe",
Certificates = new List <Certificate>
{
new Certificate {
Name = "EN455"
},
new Certificate {
Name = "EN374"
},
},
UnitOfMeasure = pieceUnit,
},
new Resource
{
Name = "Atemmasken",
Certificates = new List <Certificate>
{
new Certificate {
Name = "FFP2"
},
new Certificate {
Name = "FFP3"
},
new Certificate {
Name = "N95"
},
new Certificate {
Name = "steril"
},
new Certificate {
Name = "ventil"
},
},
UnitOfMeasure = pieceUnit,
},
new Resource
{
Name = "Betten",
UnitOfMeasure = pieceUnit,
}
};
public void TestCurrencyConversion()
{
UnitOfMeasure usd_uom = sys.CreateScalarUOM(UnitType.CURRENCY, "US-Dollar", "USD", "US 'paper' dollar");
UnitOfMeasure usdt_uom = sys.CreateScalarUOM(UnitType.CURRENCY, "Tether", "USDT", "USD 'stable' coin");
// Initial conversion rate
usdt_uom.SetConversion(0.9, usd_uom);
Quantity portfolio = new Quantity(200, usdt_uom);
Quantity portfolio_usd = portfolio.Convert(usd_uom);
Assert.IsTrue(IsCloseTo(portfolio_usd.Amount, 180.0, DELTA6));
// change conversion rate
usdt_uom.SetConversion(1.0, usd_uom);
portfolio_usd = portfolio.Convert(usd_uom);
Assert.IsTrue(IsCloseTo(portfolio_usd.Amount, 200.0, DELTA6));
}
public IEnumerable <UnitOfMeasureComponent> GetComponents(UnitOfMeasure unitOfMeasure, int power)
{
var components = new List <UnitOfMeasureComponent>();
var compositeUnitOfMeasure = unitOfMeasure as CompositeUnitOfMeasure;
if (compositeUnitOfMeasure == null)
{
components.Add(new UnitOfMeasureComponent(unitOfMeasure, power));
return(components);
}
foreach (var component in compositeUnitOfMeasure.Components)
{
components.AddRange(GetComponents(component.Unit, component.Power * power));
}
return(components);
}
public ServiceResult GetBy(string uuid)
{
if (string.IsNullOrWhiteSpace(uuid))
{
return(ServiceResponse.Error("You must provide a name for the UnitsOfMeasure."));
}
UnitOfMeasureManager UnitsOfMeasureManager = new UnitOfMeasureManager(Globals.DBConnectionKey, Request.Headers?.Authorization?.Parameter);
UnitOfMeasure s = (UnitOfMeasure)UnitsOfMeasureManager.GetBy(uuid);
if (s == null)
{
return(ServiceResponse.Error("UnitsOfMeasure could not be located for the uuid " + uuid));
}
return(ServiceResponse.OK("", s));
}
public ServiceResult Delete(string uuid)
{
if (string.IsNullOrWhiteSpace(uuid))
{
return(ServiceResponse.Error("Invalid id was sent."));
}
UnitOfMeasureManager UnitsOfMeasureManager = new UnitOfMeasureManager(Globals.DBConnectionKey, Request.Headers?.Authorization?.Parameter);
UnitOfMeasure fa = (UnitOfMeasure)UnitsOfMeasureManager.GetBy(uuid);
if (fa == null)
{
return(ServiceResponse.Error("Could not find measure."));
}
return(UnitsOfMeasureManager.Delete(fa));
}
private void DrawUnitOfMeasureField()
{
UnitOfMeasure temp = (UnitOfMeasure)EditorGUILayout.EnumPopup("Unit of Measure", (UnitOfMeasure)_unitOfMeasure.enumValueIndex);
if (temp != (UnitOfMeasure)_unitOfMeasure.enumValueIndex)
{
if (temp == UnitOfMeasure.Imperial)
{
_focusDistance.floatValue = ProCamsUtility.Convert(_focusDistance.floatValue, Units.Meter, Units.Foot);
}
else
{
_focusDistance.floatValue = ProCamsUtility.Convert(_focusDistance.floatValue, Units.Foot, Units.Meter);
}
_unitOfMeasure.enumValueIndex = (int)temp;
}
}
public static string GetUnitType(UnitOfMeasure unit)
{
string typeName = string.Empty;
switch ((UnitOfMeasure) unit)
{
case UnitOfMeasure.Text: typeName = "System.String";
break;
case UnitOfMeasure.Currency: typeName = "System.Int64";
break;
case UnitOfMeasure.Date: typeName = "System.DateTime";
break;
case UnitOfMeasure.Boolean: typeName = "System.String";
break;
}
return typeName;
}
private void DrawUnitOfMeasureField()
{
UnitOfMeasure temp = (UnitOfMeasure)EditorGUILayout.EnumPopup("Unit of Measure", _unitOfMeasure);
if (temp != _unitOfMeasure)
{
if (temp == UnitOfMeasure.Imperial)
{
_focusDistance = ProCamsUtility.Convert(_focusDistance, Units.Meter, Units.Foot);
}
else
{
_focusDistance = ProCamsUtility.Convert(_focusDistance, Units.Foot, Units.Meter);
}
_unitOfMeasure = temp;
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Recipe>(entity =>
{
ConfigureBaseModel(entity);
entity.Property(e => e.Name).IsRequired().HasMaxLength(256);
entity.Property(e => e.Description);
entity.HasMany(e => e.RecipeIngredients)
.WithOne(o => o.Recipe)
.HasForeignKey("RecipeId");
});
modelBuilder.Entity <RecipeIngredient>(entity =>
{
ConfigureBaseModel(entity);
entity.Property <long>("RecipeId");
entity.HasOne(e => e.Recipe)
.WithMany(r => r.RecipeIngredients)
.HasForeignKey("RecipeId");
entity.Property(o => o.UnitOfMeasure).IsRequired()
.HasConversion(
enm => enm.Value,
id => UnitOfMeasure.FromValue(id))
.HasColumnName("unit_of_measure_id");
entity.Property <long>("IngredientId");
entity.HasOne(e => e.Ingredient)
.WithMany()
.HasForeignKey("IngredientId");
});
modelBuilder.Entity <Ingredient>(entity =>
{
ConfigureBaseModel(entity);
entity.Property(e => e.Name).HasMaxLength(256).IsRequired();
});
}
public double Speed(UnitOfMeasure unitofMeasure)
{
// 1 kilometer = 0.539956803 nautical miles
// 1 kilometer = 0.621371192 miles
// 1 miles = 5 280 feet
if (unitofMeasure == UnitOfMeasure.Mile)
{
return(m_dbSpeedKPH * 0.621371192d);
}
if (unitofMeasure == UnitOfMeasure.Kilometer)
{
return(m_dbSpeedKPH);
}
if (unitofMeasure == UnitOfMeasure.NauticalMile)
{
return(m_dbSpeedKPH * 0.539956803d);
}
return(0);
}
/// <summary>
/// Returns true if BankingProductRateTierSubTier instances are equal
/// </summary>
/// <param name="other">Instance of BankingProductRateTierSubTier to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(BankingProductRateTierSubTier other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
UnitOfMeasure == other.UnitOfMeasure ||
UnitOfMeasure != null &&
UnitOfMeasure.Equals(other.UnitOfMeasure)
) &&
(
MinimumValue == other.MinimumValue ||
MinimumValue != null &&
MinimumValue.Equals(other.MinimumValue)
) &&
(
MaximumValue == other.MaximumValue ||
MaximumValue != null &&
MaximumValue.Equals(other.MaximumValue)
) &&
(
RateApplicationMethod == other.RateApplicationMethod ||
RateApplicationMethod != null &&
RateApplicationMethod.Equals(other.RateApplicationMethod)
) &&
(
ApplicabilityConditions == other.ApplicabilityConditions ||
ApplicabilityConditions != null &&
ApplicabilityConditions.SequenceEqual(other.ApplicabilityConditions)
));
}
void AddSameUnits(XElement unit, UnitOfMeasure unitOfMeasure)
{
var sameUnits = unit.Descendants("SameUnit");
foreach (var sameUnit in sameUnits)
{
unitOfMeasure.SameUnits = new List <SameUnit>();
var s = sameUnit.Attribute("uom");
if (s != null)
{
unitOfMeasure.SameUnits.Add(new SameUnit(s.Value));
}
else
{
Console.WriteLine("error, no attribute uom for same unit");
}
}
}
public HttpResponseMessage Post(FormDataCollection form)
{
var model = new UnitOfMeasure();
var values = JsonConvert.DeserializeObject <IDictionary>(form.Get("values"));
PopulateModel(model, values);
Validate(model);
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, GetFullErrorMessage(ModelState)));
}
var result = _context.UnitOfMeasures.Add(model);
_context.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.Created, result.UnitOfMeasureId));
}
private void NormalizeValues( Dictionary<string,long> values, UnitOfMeasure unitOfMeasure )
{
long total_time = 0;
foreach (string key in labels) {
if( !values.ContainsKey(key) )
continue;
switch (unitOfMeasure) {
case UnitOfMeasure.Ticks:
break;
case UnitOfMeasure.Microseconds:
values[key] = (long)(values[key] * 1000000.0 / Stopwatch.Frequency);
break;
case UnitOfMeasure.Milliseconds:
values[key] = (long)(values[key] * 1000.0 / Stopwatch.Frequency);
break;
case UnitOfMeasure.Seconds:
values[key] = (long)(values[key] / Stopwatch.Frequency);
break;
}
total_time += values[key];
}
values.Add("#Total", total_time);
}
public void Load( string fileName, UnitOfMeasure unitOfMeasure )
{
AverageValues.Clear();
AllValues.Clear();
labels.Clear();
// Чтение файла
List<Checkpoint> points = new List<Checkpoint>();
using (StreamReader sr = new StreamReader(fileName)) {
string str = sr.ReadLine(); // time
DateTime.TryParse(str, out time);
name = sr.ReadLine(); // name
descr = sr.ReadLine(); // description
string line;
while ((line = sr.ReadLine()) != null)
{
string[] split = line.Split( new char[]{' '} );
if( split[0] == "[CP]" )
{
string label = split[1].Trim( new char[]{':'} );
string tick = split[2].Trim();
long longTick = Int64.Parse(tick);
points.Add( new Checkpoint(label, longTick) );
}
}
}
string startLabel = points[0].Label;
points.Add( new Checkpoint(startLabel, 0) ); // завершающая метка
// Вычисление статистики
// Создание списка меток без повторений.
AverageValues[startLabel] = 0;
Dictionary<string,long> CurrentValues = new Dictionary<string,long>();
CurrentValues[startLabel] = 0;
// Цикл по блокам, от startLabel до startLabel
int num_blocks = 0;
for (int i = 1; i < points.Count; i++) {
if( points[i].Label == startLabel ) { // конец старого и начало нового блока
num_blocks++;
AllValues.Add(CurrentValues);
CurrentValues = new Dictionary<string,long>();
CurrentValues[startLabel] = 0;
} else {
if( !AverageValues.ContainsKey( points[i].Label ) )
AverageValues.Add( points[i].Label, 0);
if( !CurrentValues.ContainsKey( points[i].Label ) )
CurrentValues.Add( points[i].Label, 0);
AverageValues[ points[i].Label ] += points[i].Tick - points[i-1].Tick;
CurrentValues[ points[i].Label ] += points[i].Tick - points[i-1].Tick;
}
}
// Заполнение таблицы расстояний между метками
foreach (string key in AverageValues.Keys)
labels.Add(key);
foreach (Dictionary<string,long> values in AllValues) {
NormalizeValues(values, unitOfMeasure);
}
NormalizeValues(AverageValues, unitOfMeasure);
AverageValues.Add("#Count", num_blocks);
foreach (string key in labels) {
AverageValues[key] = AverageValues[key] / num_blocks;
}
AverageValues[startLabel] = AverageValues["#Total"] / AverageValues["#Count"];
}
public PerfTestResult( string fileName, UnitOfMeasure unit )
{
Load(fileName, unit);
}
public static UnitOfMeasure CreateUnitOfMeasure(int ID, string uOMName, bool discontinued, byte[] rowVersion)
{
UnitOfMeasure unitOfMeasure = new UnitOfMeasure();
unitOfMeasure.Id = ID;
unitOfMeasure.UOMName = uOMName;
unitOfMeasure.Discontinued = discontinued;
unitOfMeasure.RowVersion = rowVersion;
return unitOfMeasure;
}
private void DrawUnitOfMeasureField()
{
UnitOfMeasure temp = (UnitOfMeasure) EditorGUILayout.EnumPopup("Unit of Measure", _unitOfMeasure);
if (temp != _unitOfMeasure)
{
if(temp == UnitOfMeasure.Imperial)
{
_focusDistance = ProCamsUtility.Convert(_focusDistance, Units.Meter, Units.Foot);
}
else
{
_focusDistance = ProCamsUtility.Convert(_focusDistance, Units.Foot, Units.Meter);
}
_unitOfMeasure = temp;
}
}
public string UpdateUnit(int id = 0, string name = "", string code = "")
{
CurtDevDataContext db = new CurtDevDataContext();
UnitOfMeasure unit = new UnitOfMeasure();
unit = db.UnitOfMeasures.Where(x => x.ID.Equals(id)).FirstOrDefault<UnitOfMeasure>();
if (unit != null) {
unit.name = name;
unit.code = code;
db.SubmitChanges();
}
return JsonConvert.SerializeObject(unit);
}
public double Speed(UnitOfMeasure unitofMeasure)
{
// 1 kilometer = 0.539956803 nautical miles
// 1 kilometer = 0.621371192 miles
// 1 miles = 5 280 feet
if (unitofMeasure == UnitOfMeasure.Mile) return (m_dbSpeedKPH*0.621371192d);
if (unitofMeasure == UnitOfMeasure.Kilometer) return (m_dbSpeedKPH);
if (unitofMeasure == UnitOfMeasure.NauticalMile) return (m_dbSpeedKPH*0.539956803d );
return 0;
}
////////////////////////////////////////////////////////////////////
/// <summary>
/// PDF document constructor
/// </summary>
/// <param name="Width">Page width.</param>
/// <param name="Height">Page height.</param>
/// <param name="UnitOfMeasure">Unit of measure code.</param>
/// <param name="Stream">File or memory stream.</param>
/// <remarks>
/// <para>This constructor generates a document with default page size
/// as per width and height arguments in user units.</para>
/// <para>Page orientation is portrait if width is less than height.
/// Otherwise it is landscape.</para>
/// <para>Unit of measure is a an enumeration constant (Point, Inch, cm, mm)</para>
/// <para>The PDF document will be saved in the stream argument. The stream can
/// be either a MemoryStream or a FileStream. It is the calling program
/// responsibiliy to close the stream after CreateFile() method
/// is called.</para>
/// </remarks>
////////////////////////////////////////////////////////////////////
public PdfDocument(
Double Width, // page width
Double Height, // page height
UnitOfMeasure UnitOfMeasure, // unit of measure: Point, Inch, cm, mm
Stream Stream
)
{
// constructor helper
Double Scale = UnitInPoints[(Int32) UnitOfMeasure];
ConstructorHelper(Scale * Width, Scale * Height, Scale, null, Stream);
return;
}
/// <summary>
/// Initializes a new instance of the <see cref="InvoiceLineItem"/> class with the specified details.
/// </summary>
/// <param name="amountExcludingVat">The amount of the line item in GBP, excluding VAT.</param>
/// <param name="description">Description.</param>
public InvoiceLineItem(
decimal amountExcludingVat,
string description)
{
// Note: lengths are checked in the set property methods.
AmountExcludingVAT = amountExcludingVat;
Description = description;
// Set property default values
VatCode = null;
AreaCode = "H";
IncomeStreamCode = "W";
ContextCode = "H";
Quantity = 1;
UnitOfMeasure = UnitOfMeasure.Each;
}
public UnitOfMeasureComponent(UnitOfMeasure unit, int power)
{
Unit = unit;
Power = power;
}
private string ConvertUnitOfMeasureToString(UnitOfMeasure unitOfMeasure)
{
switch (unitOfMeasure)
{
case UnitOfMeasure.Each:
return "Each";
default:
throw new NotSupportedException();
}
}
public PerfTest( string name, string descr, UnitOfMeasure unit )
{
unitOfMeasure = unit;
traceFileName = GetNextFileName(name);
FileStream traceLog = new FileStream(traceFileName, FileMode.Create);
traceListener = new TextWriterTraceListener(traceLog);
Trace.Listeners.Add(traceListener);
Trace.AutoFlush = true;
Trace.WriteLine(DateTime.Now);
Trace.WriteLine(name);
Trace.WriteLine( (descr != null) ? descr : "" );
isRunning = true;
}
public FromToConversion(UnitOfMeasure from, UnitOfMeasure to) {
To = to; From = from;
}
public NumericValue(UnitOfMeasure uom, double value)
{
UnitOfMeasure = uom;
Value = value;
}
public string GetUnitDisplayFor(double amount, UnitOfMeasure _unit) { return ""; }
public static void SetTarget(this NumericRepresentationValue numericRepresentationValue, UnitOfMeasure targetUom)
{
numericRepresentationValue.Value.ConvertToUnit(targetUom);
}
public void AddToUnitOfMeasures(UnitOfMeasure unitOfMeasure)
{
base.AddObject("UnitOfMeasures", unitOfMeasure);
}
private static void WalkUnitOfMeasureSetRet(XmlNode UnitOfMeasureSetRet)
{
if (UnitOfMeasureSetRet == null) return;
UnitOfMeasure uom = null;
RotoTrackDb db = new RotoTrackDb();
string ListID = UnitOfMeasureSetRet.SelectSingleNode("./ListID").InnerText;
if (db.UnitOfMeasures.Any(f => f.QBListId == ListID))
{
uom = db.UnitOfMeasures.First(f => f.QBListId == ListID);
}
else
{
uom = new UnitOfMeasure();
db.UnitOfMeasures.Add(uom);
}
uom.QBListId = ListID;
string IsActive = "false";
if (UnitOfMeasureSetRet.SelectSingleNode("./IsActive") != null)
{
IsActive = UnitOfMeasureSetRet.SelectSingleNode("./IsActive").InnerText;
}
uom.IsActive = (IsActive == "true") ? true : false;
/*
//Go through all the elements of UnitOfMeasureSetRet
//Get value of ListID
if (UnitOfMeasureSetRet.SelectSingleNode("./ListID") != null)
{
string ListID = UnitOfMeasureSetRet.SelectSingleNode("./ListID").InnerText;
}
//Get value of TimeCreated
if (UnitOfMeasureSetRet.SelectSingleNode("./TimeCreated") != null)
{
string TimeCreated = UnitOfMeasureSetRet.SelectSingleNode("./TimeCreated").InnerText;
}
//Get value of TimeModified
if (UnitOfMeasureSetRet.SelectSingleNode("./TimeModified") != null)
{
string TimeModified = UnitOfMeasureSetRet.SelectSingleNode("./TimeModified").InnerText;
}
//Get value of EditSequence
if (UnitOfMeasureSetRet.SelectSingleNode("./EditSequence") != null)
{
string EditSequence = UnitOfMeasureSetRet.SelectSingleNode("./EditSequence").InnerText;
}
//Get value of Name
if (UnitOfMeasureSetRet.SelectSingleNode("./Name") != null)
{
string Name = UnitOfMeasureSetRet.SelectSingleNode("./Name").InnerText;
}
//Get value of IsActive
if (UnitOfMeasureSetRet.SelectSingleNode("./IsActive") != null)
{
string IsActive = UnitOfMeasureSetRet.SelectSingleNode("./IsActive").InnerText;
}
//Get value of UnitOfMeasureType
if (UnitOfMeasureSetRet.SelectSingleNode("./UnitOfMeasureType") != null)
{
string UnitOfMeasureType = UnitOfMeasureSetRet.SelectSingleNode("./UnitOfMeasureType").InnerText;
}
*/
//Get all field values for BaseUnit aggregate
XmlNode BaseUnit = UnitOfMeasureSetRet.SelectSingleNode("./BaseUnit");
if (BaseUnit != null)
{
//Get value of Name
string Name = UnitOfMeasureSetRet.SelectSingleNode("./BaseUnit/Name").InnerText;
//Get value of Abbreviation
string Abbreviation = UnitOfMeasureSetRet.SelectSingleNode("./BaseUnit/Abbreviation").InnerText;
uom.Name = Name + " (" + Abbreviation + ")";
}
//Done with field values for BaseUnit aggregate
/*
//Walk list of RelatedUnit aggregates
XmlNodeList RelatedUnitList = UnitOfMeasureSetRet.SelectNodes("./RelatedUnit");
if (RelatedUnitList != null)
{
for (int i = 0; i < RelatedUnitList.Count; i++)
{
XmlNode RelatedUnit = RelatedUnitList.Item(i);
//Get value of Name
string Name = RelatedUnit.SelectSingleNode("./Name").InnerText;
//Get value of Abbreviation
string Abbreviation = RelatedUnit.SelectSingleNode("./Abbreviation").InnerText;
//Get value of ConversionRatio
string ConversionRatio = RelatedUnit.SelectSingleNode("./ConversionRatio").InnerText;
}
}
//Walk list of DefaultUnit aggregates
XmlNodeList DefaultUnitList = UnitOfMeasureSetRet.SelectNodes("./DefaultUnit");
if (DefaultUnitList != null)
{
for (int i = 0; i < DefaultUnitList.Count; i++)
{
XmlNode DefaultUnit = DefaultUnitList.Item(i);
//Get value of UnitUsedFor
string UnitUsedFor = DefaultUnit.SelectSingleNode("./UnitUsedFor").InnerText;
//Get value of Unit
string Unit = DefaultUnit.SelectSingleNode("./Unit").InnerText;
}
}
*/
if (uom != null)
{
db.SaveChanges();
}
}
public MeterValueValue()
{
this.contextField = ReadingContext.SamplePeriodic;
this.formatField = ValueFormat.Raw;
this.measurandField = Measurand.EnergyActiveImportRegister;
this.locationField = Location.Outlet;
this.unitField = UnitOfMeasure.Wh;
}
////////////////////////////////////////////////////////////////////
/// <summary>
/// PDF document constructor
/// </summary>
/// <param name="PaperType">Paper type</param>
/// <param name="Landscape">True for landscape, false for portrait.</param>
/// <param name="UnitOfMeasure">Unit of measure code.</param>
/// <param name="Stream">File or memory stream.</param>
/// <remarks>
/// <para>This constructor generates a document with default page size
/// of Letter, Leagal, A3, A4 or A5.</para>
/// <para>Page orientation is determined by the landscape argument.</para>
/// <para>Unit of measure is a an enumeration constant (Point, Inch, cm, mm)</para>
/// <para>The PDF document will be saved in the stream argument. The stream can
/// be either a MemoryStream or a FileStream. It is the calling program
/// responsibiliy to close the stream after CreateFile() method
/// is called.</para>
/// </remarks>
////////////////////////////////////////////////////////////////////
public PdfDocument(
PaperType PaperType,
Boolean Landscape,
UnitOfMeasure UnitOfMeasure,
Stream Stream
)
{
// set scale factor (user units to points)
Double Scale = UnitInPoints[(Int32) UnitOfMeasure];
Double Width = PaperTypeSize[(Int32) PaperType].Width;
Double Height = PaperTypeSize[(Int32) PaperType].Height;
// for landscape swap width and height
if(Landscape) ConstructorHelper(Height, Width, Scale, null, Stream);
else ConstructorHelper(Width, Height, Scale, null, Stream);
return;
}
public bool Equals(UnitOfMeasure from, UnitOfMeasure to) {
return To.Equals(to) && From.Equals(from);
}
public static UnitOfMeasure UnitOfMeasure(int? counter)
{
var rtValue = new UnitOfMeasure();
rtValue.Name = "Name" + counter.Extra();
return rtValue;
}
public string GetUnit(int id = 0)
{
CurtDevDataContext db = new CurtDevDataContext();
UnitOfMeasure unit = new UnitOfMeasure();
try {
unit = db.UnitOfMeasures.Where(x => x.ID.Equals(id)).First<UnitOfMeasure>();
} catch { };
return JsonConvert.SerializeObject(unit);
}
