public void _04_IsIdentical_SHOULD_return_true_WHEN_both_Unit_and_PhysicalQuantity_of_new_context_match()
{
MeasurementContext newContext = new MeasurementContext(new Scale(0, 10), Unit.Celcius, PhysicalQuantity.Temperature);
bool result;
result = _context.IsIdentical(newContext);
Assert.That(result, Is.True);
}
public void _03_IsIdentical_SHOULD_return_false_WHEN_PhysicalQuantity_of_new_context_does_not_matches()
{
MeasurementContext newContext = new MeasurementContext(new Scale(0, 10), Unit.Celcius, PhysicalQuantity.Pressure);
bool result;
result = _context.IsIdentical(newContext);
Assert.That(result, Is.False);
}
public void Login()
{
using (var projectMeasurementContext = new MeasurementContext(optionsBuilder.Options))
{
projectMeasurementContext.Database.EnsureCreated();
var userRepository = new UserRepository(projectMeasurementContext);
Assert.Equal(true, userRepository.AuthenticateUser("*****@*****.**"));
}
}
public void Validate()
{
When.ValidateRequired("When");
Value.ValidateRequired("Value");
MeasurementType.ValidateOptional("MeasurementType");
OutsideOperatingTemperature.ValidateOptional("OutsideOperatingTemperature");
IsControlTest.ValidateOptional("IsControlTest");
Normalcy.ValidateOptional("Normalcy");
MeasurementContext.ValidateOptional("MeasurementContext");
}
public void _01_WithRangeFrom_SHOULD_return_the_same_instance_reference_and_configure_minimum_maximum_with_provided_values()
{
MeasurementContext expectedReference = _context, receivedReference;
receivedReference = _context.WithRangeFrom(-100);
Assert.That(receivedReference, Is.EqualTo(expectedReference));
Assert.That(receivedReference.Scale.Minimum, Is.EqualTo(-100));
Assert.That(receivedReference.Scale.Maximum, Is.EqualTo(10));
}
public async Task AddNewTask()
{
using (var projectMeasurementContext = new MeasurementContext(optionsBuilder.Options))
{
projectMeasurementContext.Database.EnsureCreated();
var userService = new UserService(new UserRepository(projectMeasurementContext));
var userController = new UserController(userService);
userController.AddNewTask("first task", "Test Project(do not delete)");
Assert.Equal(1, await projectMeasurementContext.ProjectTasks.CountAsync());
}
}
public static IMeasurementRepository <Measurement> GetInMemoryMeasurementsRepository(string dbName)
{
var options = new DbContextOptionsBuilder <MeasurementContext>()
.UseInMemoryDatabase(databaseName: dbName)
.Options;
MeasurementContext measurementContext = new MeasurementContext(options);
measurementContext.FillDatabase();
return(new MeasurementRepository(measurementContext));
}
public async Task AddProjectAndDeleteProject()
{
using (var projectMeasurementContext = new MeasurementContext(optionsBuilder.Options))
{
projectMeasurementContext.Database.EnsureCreated();
var adminController = new AdminController(new UserService(new UserRepository(projectMeasurementContext)),
new ProjectService(new ProjectRepository(projectMeasurementContext)));
adminController.AddProject("TestProject");
Assert.Equal(3, await projectMeasurementContext.Projects.CountAsync());
adminController.DeleteProject("TestProject");
Assert.Equal(2, await projectMeasurementContext.Projects.CountAsync());
};
}
public void AssignUserToProjectAndRemoveFromProject()
{
using (var projectMeasurementContext = new MeasurementContext(optionsBuilder.Options))
{
projectMeasurementContext.Database.EnsureCreated();
var userService = new UserService(new UserRepository(projectMeasurementContext));
var adminController = new AdminController(userService, new ProjectService(new ProjectRepository(projectMeasurementContext)));
adminController.RemoveUserFromProject("*****@*****.**", "Test Project(do not delete)");
Assert.Equal("You do not have assigned project", userService.UserInfo("*****@*****.**").Project.ProjectName);
adminController.AssignUser("*****@*****.**", "Test Project(do not delete)");
Assert.Equal("Test Project(do not delete)", userService.UserInfo("*****@*****.**").Project.ProjectName);
}
}
public void Invocation_WithCancellationRequested_Throws(TSutFactory factory)
{
// Fixture setup
IFixture fixture = DomainFixture.CreateFor(this);
MeasurementContext <TSeed> context = fixture.Create <MeasurementContext <TSeed> >();
CancellationToken cancellationToken = new CancellationToken(true);
PerformanceScenario <TSeed, TResult> sut = factory.CreateDelegate();
// Exercise system
// Verify outcome
Assert.Throws <OperationCanceledException>(() =>
{
sut(context, cancellationToken);
});
// Teardown
}
public void Invocation_WithNullContext_Throws(TSutFactory factory)
{
// Fixture setup
IFixture fixture = DomainFixture.CreateFor(this);
MeasurementContext <TSeed> context = null;
CancellationToken cancellationToken = fixture.Create <CancellationToken>();
PerformanceScenario <TSeed, TResult> sut = factory.CreateDelegate();
// Exercise system
// Verify outcome
Assert.Throws <ArgumentNullException>(nameof(context), () =>
{
sut(context, cancellationToken);
});
// Teardown
}
public MeasurementRepository(MeasurementContext dbCcontext)
{
_dbContext = dbCcontext;
}
public MeasurementsController(MeasurementContext measurementContext)
{
MeasurementContext = measurementContext;
}
public MeasurementRepository(MeasurementContext context)
{
this.context = context;
}
public static void FillDatabase(this MeasurementContext dbContext)
{
dbContext.Measurements.Add
(
new Measurement
{
Id = 1,
Name = "Measurement_01",
Value = 0.25m,
CreatedBy = "Operator_01",
CreatedAt = Convert.ToDateTime("2019/03/25 01:00:00 PM")
}
);
dbContext.Add
(
new Measurement
{
Id = 2,
Name = "Measurement_02",
Value = 0.50m,
CreatedBy = "Operator_01",
CreatedAt = Convert.ToDateTime("2019/03/25 02:00:00 PM")
}
);
dbContext.Add
(
new Measurement
{
Id = 3,
Name = "Measurement_03",
Value = 0.75m,
CreatedBy = "Operator_01",
CreatedAt = Convert.ToDateTime("2019/03/25 03:00:00 PM")
}
);
dbContext.Add
(
new Measurement
{
Id = 4,
Name = "Measurement_04",
Value = 1.00m,
CreatedBy = "Operator_01",
CreatedAt = Convert.ToDateTime("2019/03/25 04:00:00 PM")
}
);
dbContext.Add
(
new Measurement
{
Id = 5,
Name = "Measurement_05",
Value = 1.25m,
CreatedBy = "Operator_01",
CreatedAt = Convert.ToDateTime("2019/03/25 05:00:00 PM")
}
);
dbContext.SaveChanges();
}
public MeasurmentRepository(MeasurementContext measurmentContext)
{
_measurmentContext = measurmentContext;
}
public UserRepository(MeasurementContext measurementContext)
{
MeasurementContext = measurementContext;
CreateDefaultUser();
}
public AstrometricSolutionImpl(LeastSquareFittedAstrometry astrometry, StarMagnitudeFit photometry, AstrometricState state, FieldSolveContext fieldSolveContext, MeasurementContext measurementContext)
{
StarCatalog = fieldSolveContext.StarCatalogueFacade.CatalogNETCode;
UtcTime = fieldSolveContext.UtcTime;
FrameNoOfUtcTime = fieldSolveContext.FrameNoOfUtcTime;
AutoLimitMagnitude = (float)fieldSolveContext.AutoLimitMagnitude;
ResolvedFocalLength = (float)fieldSolveContext.FocalLength;
if (astrometry != null)
{
ResolvedCenterRADeg = (float)astrometry.RA0Deg;
ResolvedCenterDEDeg = (float)astrometry.DE0Deg;
StdDevRAArcSec = (float)astrometry.StdDevRAArcSec;
StdDevDEArcSec = (float)astrometry.StdDevDEArcSec;
ArcSecsInPixel = 1 / astrometry.GetDistanceInPixels(1);
}
else
{
ResolvedCenterRADeg = float.NaN;
ResolvedCenterDEDeg = float.NaN;
StdDevRAArcSec = float.NaN;
StdDevDEArcSec = float.NaN;
ArcSecsInPixel = 0;
}
if (state.SelectedObject != null)
{
m_UserObject = new TangraUserObjectImpl();
m_UserObject.RADeg = (float)state.SelectedObject.RADeg;
m_UserObject.DEDeg = (float)state.SelectedObject.DEDeg;
m_UserObject.X = (float)state.SelectedObject.X0;
m_UserObject.Y = (float)state.SelectedObject.Y0;
if (state.IdentifiedObjects != null &&
state.IdentifiedObjects.Count == 1)
{
foreach (IIdentifiedObject idObj in state.IdentifiedObjects)
{
if (AngleUtility.Elongation(idObj.RAHours * 15.0, idObj.DEDeg, state.SelectedObject.RADeg, state.SelectedObject.DEDeg) * 3600 < 120)
{
m_UserObject.ResolvedName = idObj.ObjectName;
break;
}
}
}
}
InstrumentalDelay = measurementContext.InstrumentalDelay;
InstrumentalDelayUnits = measurementContext.InstrumentalDelayUnits.ToString();
FrameTimeType = measurementContext.FrameTimeType.ToString();
IntegratedFramesCount = measurementContext.IntegratedFramesCount;
IntegratedExposureSeconds = measurementContext.IntegratedExposureSeconds;
AavIntegration = measurementContext.AavIntegration;
AavStackedMode = measurementContext.AavStackedMode;
VideoFileFormat = measurementContext.VideoFileFormat.ToString();
NativeVideoFormat = measurementContext.NativeVideoFormat;
if (!string.IsNullOrEmpty(state.IdentifiedObjectToMeasure))
{
ObjectDesignation = MPCObsLine.GetObjectCode(state.IdentifiedObjectToMeasure);
}
else if (state.IdentifiedObjects != null && state.IdentifiedObjects.Count == 1)
{
ObjectDesignation = MPCObsLine.GetObjectCode(state.IdentifiedObjects[0].ObjectName);
}
ObservatoryCode = fieldSolveContext.ObsCode;
CatalogueCode = measurementContext.StarCatalogueFacade.CatalogNETCode;
m_MeasurementsImpl = new List <TangraAstrometricMeasurementImpl>();
if (state.Measurements != null)
{
foreach (var mea in state.Measurements)
{
m_MeasurementsImpl.Add(new TangraAstrometricMeasurementImpl()
{
DEDeg = mea.DEDeg,
RADeg = mea.RADeg,
FrameNo = mea.FrameNo,
SolutionUncertaintyRACosDEArcSec = mea.SolutionUncertaintyRACosDEArcSec,
SolutionUncertaintyDEArcSec = mea.SolutionUncertaintyDEArcSec,
FWHMArcSec = mea.FWHMArcSec,
Detection = mea.Detection,
SNR = mea.SNR,
UncorrectedTimeStamp = mea.FrameTimeStamp,
Mag = mea.Mag
});
}
}
m_MatchedStarImpl = new List <TangraMatchedStarImpl>();
if (astrometry != null)
{
foreach (PlateConstStarPair pair in astrometry.FitInfo.AllStarPairs)
{
if (pair.FitInfo.UsedInSolution)
{
var star = new TangraMatchedStarImpl()
{
X = (float)pair.x,
Y = (float)pair.y,
RADeg = (float)pair.RADeg,
DEDeg = (float)pair.DEDeg,
StarNo = pair.StarNo,
ExcludedForHighResidual = pair.FitInfo.ExcludedForHighResidual,
ResidualRAArcSec = (float)pair.FitInfo.ResidualRAArcSec,
ResidualDEArcSec = (float)pair.FitInfo.ResidualDEArcSec,
DetectionCertainty = (float)pair.DetectionCertainty,
PSFAmplitude = (int)pair.Intensity,
IsSaturated = pair.IsSaturated,
Mag = (float)pair.Mag
};
TangraCatalogStarImpl catStar = null;
IStar catalogStar = fieldSolveContext.CatalogueStars.Find(s => s.StarNo == pair.StarNo);
if (catalogStar != null)
{
if (catalogStar is UCAC4Entry)
{
catStar = new TangraAPASSStar();
}
else
{
catStar = new TangraCatalogStarImpl();
}
catStar.StarNo = catalogStar.StarNo;
catStar.MagR = (float)catalogStar.MagR;
catStar.MagV = (float)catalogStar.MagV;
catStar.MagB = (float)catalogStar.MagB;
catStar.Mag = (float)catalogStar.Mag;
if (catalogStar is UCAC3Entry)
{
UCAC3Entry ucac3Star = (UCAC3Entry)catalogStar;
catStar.MagJ = (float)(ucac3Star.jmag * 0.001);
catStar.MagK = (float)(ucac3Star.kmag * 0.001);
catStar.RAJ2000Deg = (float)ucac3Star.RACat;
catStar.DEJ2000Deg = (float)ucac3Star.DECat;
}
else if (catalogStar is UCAC2Entry)
{
UCAC2Entry ucac2Star = (UCAC2Entry)catalogStar;
catStar.MagJ = (float)(ucac2Star._2m_J * 0.001);
catStar.MagK = (float)(ucac2Star._2m_Ks * 0.001);
catStar.RAJ2000Deg = (float)ucac2Star.RACat;
catStar.DEJ2000Deg = (float)ucac2Star.DECat;
}
else if (catalogStar is NOMADEntry)
{
NOMADEntry nomadStar = (NOMADEntry)catalogStar;
catStar.MagJ = (float)(nomadStar.m_J * 0.001);
catStar.MagK = (float)(nomadStar.m_K * 0.001);
catStar.RAJ2000Deg = (float)nomadStar.RACat;
catStar.DEJ2000Deg = (float)nomadStar.DECat;
}
else if (catalogStar is UCAC4Entry)
{
UCAC4Entry ucac4Star = (UCAC4Entry)catalogStar;
catStar.MagJ = (float)(ucac4Star.MagJ);
catStar.MagK = (float)(ucac4Star.MagK);
catStar.RAJ2000Deg = (float)ucac4Star.RACat;
catStar.DEJ2000Deg = (float)ucac4Star.DECat;
((TangraAPASSStar)catStar).B = (float)ucac4Star.MagB;
((TangraAPASSStar)catStar).V = (float)ucac4Star.MagV;
((TangraAPASSStar)catStar).g = (float)ucac4Star.Mag_g;
((TangraAPASSStar)catStar).r = (float)ucac4Star.Mag_r;
((TangraAPASSStar)catStar).i = (float)ucac4Star.Mag_i;
((TangraAPASSStar)catStar).e_B = ucac4Star.apase_B * 0.001f;
((TangraAPASSStar)catStar).e_V = ucac4Star.apase_V * 0.001f;
((TangraAPASSStar)catStar).e_g = ucac4Star.apase_g * 0.001f;
((TangraAPASSStar)catStar).e_r = ucac4Star.apase_r * 0.001f;
((TangraAPASSStar)catStar).e_i = ucac4Star.apase_i * 0.001f;
}
}
star.CatalogStar = catStar;
if (photometry != null)
{
IStar photometryStar = photometry.StarNumbers.FirstOrDefault(s => s.StarNo == pair.StarNo);
if (photometryStar != null)
{
int idx = photometry.StarNumbers.IndexOf(photometryStar);
star.Intensity = (float)photometry.Intencities[idx];
star.IsSaturated = photometry.SaturatedFlags[idx];
star.MeaSignalMethod = ConvertSignalMethod(photometry.MeaSignalMethod);
star.MeaBackgroundMethod = ConvertBackgroundMethod(photometry.MeaBackgroundMethod);
star.MeaSingleApertureSize = photometry.MeaSingleAperture;
star.MeaBackgroundPixelCount = photometry.MeaBackgroundPixelCount;
star.MeaSaturationLevel = photometry.MeaSaturationLevel;
}
}
m_MatchedStarImpl.Add(star);
}
}
}
}
public MeasurementRepository(MeasurementContext _measurementContext)
{
this._measurementContext = _measurementContext;
}
public void Setup()
{
_context = new MeasurementContext(new Scale(1, 10), Unit.Celcius, PhysicalQuantity.Temperature);
}
/// <summary>
/// Configures the Measurement Context (Physical Quantity being measured and it's Scale, Units) for
/// measurements taken for the current pin.
/// </summary>
/// <typeparam name="T">The Measurement Context to configure from.</typeparam>
public MeasurementContext ConfigureScaleFor <T>() where T : MeasurementContext, new()
{
ConfiguredMeasurementContext = new T();
return(ConfiguredMeasurementContext);
}
public MeasurementLog()
{
InitializeComponent();
Loaded += (s, e) =>
{
// Setup control event handlers
Calendar.SelectedDate = Globals.SelectedDate;
Calendar.SelectedDatesChanged += (se, ev) =>
{
if (Calendar.SelectedDate.HasValue)
{
Globals.SelectedDate = Calendar.SelectedDate.Value;
LoadCurrentImage();
}
};
MeasurementLogGrid.LayoutUpdated += (se, ev) => { DataGridHelper.ResizeGrid(0, MeasurementLogGrid); };
MeasurementLogGrid.RowEditEnded += new EventHandler <DataGridRowEditEndedEventArgs>(MeasurementLogGrid_RowEditEnded);
MeasurementLogGrid.LoadingRow += new EventHandler <DataGridRowEventArgs>(MeasurementLogGrid_LoadingRow);
CustomMeasurement.Click += new RoutedEventHandler(CustomMeasurement_Click);
UpdateImage.Click += new RoutedEventHandler(UpdateImage_Click);
DeleteSelected.Click += new RoutedEventHandler(DeleteSelected_Click);
// Hold onto a copy of the MeasurementContext contained in the XAML
context = this.Resources["MeasurementContext"] as MeasurementContext;
Parameter user_id = new Parameter();
user_id.ParameterName = "user_id";
user_id.Value = Globals.CurrentUser.id;
// Ensure that the user_id parameter is set for the DomainDataSource control before the query is executed
MeasurementData.QueryParameters.Add(user_id);
// Ensure that whenever data is being loaded into the DomainContext the ProgressBar control is visible
// The ProgressBarVisibilityConverter will ensure that when IsLoading is true the Visibility is set to visible, false otherwise
Binding binding = new Binding();
binding.Source = context;
binding.Path = new PropertyPath("IsLoading");
binding.Converter = new ProgressBarVisibilityConverter();
ProgressBar.SetBinding(ProgressBar.VisibilityProperty, binding);
// Setup the ComboBox control now that the MeasurementContext is available
context.Load <FitnessTrackerPlus.Web.Data.Measurement>(context.GetMeasurementsQuery(Globals.CurrentUser.id),
LoadBehavior.RefreshCurrent, (MeasurementsLoaded) =>
{
if (!MeasurementsLoaded.HasError)
{
Measurements.ItemsSource = MeasurementsLoaded.Entities;
Measurements.SelectedIndex = 0;
}
}, null);
Measurements.SelectionChanged += (se, ev) =>
{
FitnessTrackerPlus.Web.Data.Measurement selected = Measurements.SelectedItem as FitnessTrackerPlus.Web.Data.Measurement;
if (selected.id > 0)
{
CreateMeasurementLogEntry(selected);
}
};
LoadCurrentImage();
};
}
public ProjectRepository(MeasurementContext measurementContext)
{
MeasurementContext = measurementContext;
CreateDefaultProject();
}
internal FastAsteroidTracker(AstrometryController astrometryController, MeasurementContext measurementContext)
{
m_AstrometryController = astrometryController;
m_MeasurementContext = measurementContext;
}
internal FastMotionTracker(AstrometryController astrometryController, MeasurementContext measurementContext)
{
m_AstrometryController = astrometryController;
m_MeasurementContext = measurementContext;
}
public PersonsController(MeasurementContext context)
{
_context = context;
}
public TaskRepository(MeasurementContext measurementContext)
{
MeasurementContext = measurementContext;
}
public MeasurementsController(MeasurementContext context)
{
_context = context;
}
public MeasurementRepository(MeasurementContext dbcontext)
{
this.dbcontext = dbcontext;
}
