public IList <Pipe> GetPipesToExport()
{
try
{
// PipeTestResult result = null;
// Inspector inspector = null;
// Certificate certificate = null;
// var q = session.QueryOver<Pipe>()
// .Where(n => ((n.ToExport == true)))
// .JoinAlias(r => r.PipeTestResult, () => result, JoinType.LeftOuterJoin)
// .JoinAlias(() => result.Inspectors, () => inspector, JoinType.LeftOuterJoin)
// .JoinAlias(() => inspector.Certificates, () => certificate, JoinType.LeftOuterJoin)
// .TransformUsing(Transformers.DistinctRootEntity)
// .List<Pipe>();
//return q;
Plate plate = null;
Heat heat = null;
PlateManufacturer plateMan = null;
PipeMillSizeType type = null;
PipeTest tests = null;
PipeTestResult result = null;
Inspector inspector = null;
Certificate certificate = null;
Project proj = null;
SeamType seam = null;
Spool spool = null;
File attach = null;
var q = session.QueryOver <Pipe>()
.Where(n => ((n.ToExport == true)))
.JoinAlias(r => r.PipeTestResult, () => result, JoinType.LeftOuterJoin)
.JoinAlias(() => result.Inspectors, () => inspector, JoinType.LeftOuterJoin)
.JoinAlias(() => inspector.Certificates, () => certificate, JoinType.LeftOuterJoin)
.JoinAlias(p => p.Plate, () => plate, JoinType.LeftOuterJoin)
.JoinAlias(() => plate.Heat, () => heat, JoinType.LeftOuterJoin)
.JoinAlias(() => heat.PlateManufacturer, () => plateMan, JoinType.LeftOuterJoin)
.JoinAlias(t => t.Type, () => type, JoinType.LeftOuterJoin)
.JoinAlias(() => type.SeamType, () => seam, JoinType.LeftOuterJoin)
.JoinAlias(() => type.PipeTests, () => tests, JoinType.LeftOuterJoin)
.JoinAlias(t => t.Spools, () => spool, JoinType.LeftOuterJoin)
.JoinAlias(t => t.Attachments, () => attach, JoinType.LeftOuterJoin)
.JoinAlias(t => t.Project, () => proj, JoinType.LeftOuterJoin)
.Fetch(o => o.PurchaseOrder).Eager
.Fetch(r => r.Railcar).Eager
.TransformUsing(Transformers.DistinctRootEntity)
.List <Pipe>();
return(q);
}
catch (GenericADOException ex)
{
throw new RepositoryException("GetPipesToExport", ex);
}
}
/// <summary>
/// Creates predefined pipe test result for all active required availableTests for concrete pipe mill size type
/// </summary>
/// <param name="millSizeType"></param>
public BindingList <PipeTestResult> GetRequired(PipeMillSizeType millSizeType)
{
BindingList <PipeTestResult> requiredTestResults = new BindingList <PipeTestResult>();
var criteria = NHibernate.Criterion.DetachedCriteria
.For <PipeTest>()
.Add(Restrictions.Eq("FrequencyType", InspectionFrequencyType.R))
.Add(Restrictions.Eq("pipeType", millSizeType))
.Add(Restrictions.Eq("IsActive", true));
IList <PipeTest> requiredTests = repoMill.RepoPipeTest.GetByCriteria(criteria);
GetAvailableTests();
foreach (var requiredTest in requiredTests)
{
PipeTestResult requiredResult = new PipeTestResult()
{
Operation = requiredTest,
IsActive = true,
Status = PipeTestResultStatus.Scheduled,
Pipe = Pipe,
Inspectors = new BindingList <Prizm.Domain.Entity.Inspector>()
};
requiredTestResults.Add(requiredResult);
requiredResult.Order++;
}
return(requiredTestResults);
}
public void NewPipe()
{
currentType = new PipeMillSizeType();
extractPurchaseOrderCommand.Execute();
extractHeatsCommand.Execute();
extractPipeTypeCommand.Execute();
this.Pipe = new Pipe();
this.PipePurchaseOrder = null;
this.Heat = null;
this.PlateNumber = string.Empty;
this.Pipe.IsActive = true;
this.Pipe.IsAvailableToJoint = true;
this.Pipe.Status = PipeMillStatus.Produced;
this.Pipe.ConstructionStatus = Domain.Entity.Construction.PartConstructionStatus.Pending;
this.Pipe.InspectionStatus = Domain.Entity.Construction.PartInspectionStatus.Pending;
this.Pipe.Project = repoMill.RepoProject.GetSingle();
this.Number = string.Empty;
this.Mill = string.Empty;
this.WallThickness = 0;
this.Weight = 0;
this.Length = 0;
this.Diameter = 0;
this.PipeTestResults = new BindingList <PipeTestResult>();
if (this.FilesFormViewModel != null)
{
this.FilesFormViewModel.RefreshFiles(this.Pipe.Id);
}
this.Pipe.Mill = mill;
this.Pipe.ToExport = false;
}
private PipeMillSizeType ImportSizeType(SizeTypeObject sizeTypeObj)
{
if (sizeTypeObj == null)
{
return(null);
}
bool isNew = false;
PipeMillSizeType type = importRepo.SizeTypeRepo.Get(sizeTypeObj.Id);
if (type == null)
{
type = new PipeMillSizeType();
isNew = true;
}
type.Id = sizeTypeObj.Id;
type.IsActive = sizeTypeObj.IsActive;
type.Type = sizeTypeObj.Type;
type.Length = sizeTypeObj.Length;
type.Diameter = sizeTypeObj.Diameter;
type.Thickness = sizeTypeObj.Thickness;
type.SeamType = ImportSeamType(sizeTypeObj.SeamType);
if (isNew)
{
importRepo.SizeTypeRepo.Save(type);
}
else
{
importRepo.SizeTypeRepo.SaveOrUpdate(type);
}
return(type);
}
public SizeTypeObject(PipeMillSizeType sizeType)
{
this.Id = sizeType.Id;
this.IsActive = sizeType.IsActive;
this.Type = sizeType.Type;
this.Length = sizeType.Length;
this.Diameter = sizeType.Diameter;
this.Thickness = sizeType.Thickness;
this.SeamType = sizeType.SeamType;
}
public IList <PipeTest> GetByMillSizeType(PipeMillSizeType pipeType)
{
try
{
return(session.QueryOver <PipeTest>().Where(n => n.pipeType == pipeType).List <PipeTest>());
}
catch (GenericADOException ex)
{
throw new RepositoryException("GetByMillSizeType", ex);
}
}
internal void UpdatePipeTests(object sizeType)
{
PipeMillSizeType type = sizeType as PipeMillSizeType;
PipeTests.Clear();
if (type.PipeTests == null)
{
return;
}
foreach (PipeTest t in type.PipeTests)
{
PipeTests.Add(t);
}
}
/// <summary>
///Refreshes list of required pipe test
/// </summary>
private void RefreshPipeTest(PipeMillSizeType currentPipeType)
{
if (currentPipeType != null && viewModel.Pipe.Type != currentPipeType)
{
viewModel.PipeMillSizeType = currentPipeType;
viewModel.PipeTestResults = viewModel.GetRequired(currentPipeType);
viewModel.Pipe.PipeTestResult = viewModel.PipeTestResults;
inspectionCodeLookUpEdit.DataSource = viewModel.AvailableTests;
inspections.RefreshDataSource();
}
viewModel.PipeMillSizeType = pipeSize.SelectedItem as PipeMillSizeType;
commandManager.RefreshVisualState();
}
public void NewPipe()
{
try
{
currentType = new PipeMillSizeType()
{
IsNative = true, Project = this.Project
};
extractPurchaseOrderCommand.Execute();
extractHeatsCommand.Execute();
extractPipeTypeCommand.Execute();
this.Pipe = new Pipe();
this.PipePurchaseOrder = null;
this.Heat = null;
this.PlateNumber = string.Empty;
this.Pipe.IsActive = true;
this.Pipe.IsAvailableToJoint = true;
this.Pipe.Status = PipeMillStatus.Produced;
this.Pipe.ConstructionStatus = Domain.Entity.Construction.PartConstructionStatus.Pending;
this.Pipe.InspectionStatus = Domain.Entity.Construction.PartInspectionStatus.Pending;
this.Pipe.Project = repoMill.RepoProject.GetSingle();
this.Number = string.Empty;
this.Mill = string.Empty;
this.WallThickness = 0;
this.Weight = 0;
this.Length = 0;
this.Diameter = 0;
this.PipeTestResults = new BindingList <PipeTestResult>();
if (this.FilesFormViewModel != null)
{
this.FilesFormViewModel.Files = null;
}
this.Pipe.Mill = mill;
this.Pipe.ToExport = false;
PipeNotifier = NotificationService.Instance.NotRequiredOperationManager.CreateNotifier(Pipe);
SelectiveOperationPipeNotifier = NotificationService.Instance.SelectiveOperationManager.CreateNotifier(Pipe);
}
catch (RepositoryException ex)
{
log.Warn(this.GetType().Name + " | " + ex.ToString());
notify.ShowWarning(Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Message),
Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Header));
}
}
public void TestSaveSettings()
{
var notify = new Mock <IUserNotify>();
var repoPipeSize = new Mock <IMillPipeSizeTypeRepository>();
var repoPipeTests = new Mock <IPipeTestRepository>();
var repoWelders = new Mock <IWelderRepository>();
var repoInspectors = new Mock <IInspectorRepository>();
var repoManufacturers = new Mock <IPlateManufacturerRepository>();
var repoProjectSetting = new Mock <IProjectRepository>();
var repoUsers = new Mock <IUserRepository>();
var repoRoles = new Mock <IRoleRepository>();
var repoPerms = new Mock <IPermissionRepository>();
var repoCategory = new Mock <ICategoryRepository>();
var repoJointOperation = new Mock <IJointOperationRepository>();
var repoCertificateType = new Mock <ICertificateTypeRepository>();
var repoComponentType = new Mock <IComponentTypeRepository>();
var repoSeamType = new Mock <ISeamTypeRepository>();
var testProjectSetting = new Project()
{
IsNative = true
};
var testSizeType = new PipeMillSizeType();
var testWelder = new Welder();
var testManufacturer = new PlateManufacturer();
var testInspector = new Inspector();
var testUser = new User();
var testRole = new Role();
var testPerm = new Permission();
var modifiableView = new Mock <IModifiable>();
var jointOperations = new JointOperation();
var ctx = new Mock <ISecurityContext>();
repoPipeSize.Setup(_ => _.GetAll()).Returns(new List <PipeMillSizeType>()
{
testSizeType
});
repoWelders.Setup(_ => _.GetAll()).Returns(new List <Welder>()
{
testWelder
});
repoManufacturers.Setup(_ => _.GetAll()).Returns(new List <PlateManufacturer>()
{
testManufacturer
});
repoProjectSetting.Setup(_ => _.GetSingle()).Returns(testProjectSetting);
repoInspectors.Setup(_ => _.GetAll()).Returns(new List <Inspector>()
{
testInspector
});
repoUsers.Setup(_ => _.GetAll()).Returns(new List <User>()
{
testUser
});
repoRoles.Setup(_ => _.GetAll()).Returns(new List <Role>()
{
testRole
});
repoPerms.Setup(_ => _.GetAll()).Returns(new List <Permission>()
{
testPerm
});
repoJointOperation.Setup(_ => _.GetAll()).Returns(new List <JointOperation>()
{
jointOperations
});
repoCategory.Setup(x => x.GetAll()).Returns(new List <Category>()
{
new Category()
});
repoCertificateType.Setup(x => x.GetAll()).Returns(new List <InspectorCertificateType>()
{
new InspectorCertificateType()
});
repoComponentType.Setup(x => x.GetAll()).Returns(new List <ComponentType>()
{
new ComponentType()
});
Mock <ISettingsRepositories> settingsRepos = new Mock <ISettingsRepositories>();
settingsRepos.SetupGet(_ => _.PipeSizeTypeRepo).Returns(repoPipeSize.Object);
settingsRepos.SetupGet(_ => _.PipeTestRepo).Returns(repoPipeTests.Object);
settingsRepos.SetupGet(_ => _.WelderRepo).Returns(repoWelders.Object);
settingsRepos.SetupGet(_ => _.PlateManufacturerRepo).Returns(repoManufacturers.Object);
settingsRepos.SetupGet(_ => _.ProjectRepo).Returns(repoProjectSetting.Object);
settingsRepos.SetupGet(_ => _.InspectorRepo).Returns(repoInspectors.Object);
settingsRepos.SetupGet(_ => _.UserRepo).Returns(repoUsers.Object);
settingsRepos.SetupGet(_ => _.RoleRepo).Returns(repoRoles.Object);
settingsRepos.SetupGet(_ => _.PermissionRepo).Returns(repoPerms.Object);
settingsRepos.SetupGet(_ => _.JointRepo).Returns(repoJointOperation.Object);
settingsRepos.SetupGet(x => x.СategoryRepo).Returns(repoCategory.Object);
settingsRepos.SetupGet(x => x.CertificateTypeRepo).Returns(repoCertificateType.Object);
settingsRepos.SetupGet(x => x.ComponentTypeRepo).Returns(repoComponentType.Object);
settingsRepos.SetupGet(x => x.SeamTypeRepo).Returns(repoSeamType.Object);
var viewModel = new SettingsViewModel(settingsRepos.Object, notify.Object, ctx.Object);
viewModel.ModifiableView = modifiableView.Object;
viewModel.LoadData();
viewModel.ModifiableView = modifiableView.Object;
var validatable = new Mock <IValidatable>();
validatable.Setup(x => x.Validate()).Returns(true);
viewModel.validatableView = validatable.Object;
var command = new SaveSettingsCommand(viewModel, settingsRepos.Object, notify.Object, ctx.Object);
command.Execute();
settingsRepos.Verify(_ => _.BeginTransaction(), Times.Once());
repoPipeSize.Verify(_ => _.SaveOrUpdate(testSizeType), Times.Once());
settingsRepos.Verify(_ => _.Commit(), Times.Once());
repoPipeSize.Verify(_ => _.Evict(testSizeType), Times.Once());
repoWelders.Verify(_ => _.SaveOrUpdate(testWelder), Times.Once());
repoWelders.Verify(_ => _.Evict(testWelder), Times.Once());
repoManufacturers.Verify(_ => _.SaveOrUpdate(testManufacturer), Times.Once());
repoManufacturers.Verify(_ => _.Evict(testManufacturer), Times.Once());
repoProjectSetting.Verify(_ => _.SaveOrUpdate(testProjectSetting), Times.Once());
repoProjectSetting.Verify(_ => _.Evict(testProjectSetting), Times.Once());
repoInspectors.Verify(_ => _.SaveOrUpdate(testInspector), Times.Once());
repoInspectors.Verify(_ => _.Evict(testInspector), Times.Once());
repoUsers.Verify(_ => _.SaveOrUpdate(testUser), Times.Once());
repoUsers.Verify(_ => _.Evict(testUser), Times.Once());
repoRoles.Verify(_ => _.SaveOrUpdate(testRole), Times.Once());
repoRoles.Verify(_ => _.Evict(testRole), Times.Once());
}
