Emmanuele Sassi
2192 lines
95 KiB
VB.net
2192 lines
95 KiB
VB.net
Imports System.Collections.ObjectModel
|
|
Imports System.IO
|
|
Imports System.IO.Compression
|
|
Imports System.Windows.Threading
|
|
Imports EgtBEAMWALL.Core
|
|
Imports EgtBEAMWALL.DataLayer.DatabaseModels
|
|
Imports EgtUILib
|
|
Imports EgtWPFLib5
|
|
Imports Newtonsoft.Json
|
|
|
|
Public Class ProdManagerVM
|
|
Inherits VMBase
|
|
|
|
#Region "FIELDS & PROPERTIES"
|
|
|
|
Private DOWN_IMAGE As String = "pack://application:,,,/Resources/NewPage/down.png"
|
|
Private UP_IMAGE As String = "pack://application:,,,/Resources/NewPage/up.png"
|
|
Private PADLOCK_IMAGE As String = "pack://application:,,,/Resources/NewPage/padlock.png"
|
|
|
|
' Nome file NGE con i pezzi selezionati per effettuare UpdateBTL
|
|
Friend Const UPDATEBTL_NGE As String = "UpdateBTL.nge"
|
|
|
|
Private m_OpenProj_Timer As New DispatcherTimer
|
|
Private m_bOpenProj As Boolean = False
|
|
Private m_nProjIdToOpen As Integer = GDB_ID.NULL
|
|
|
|
Private m_OptimizerManager_IsEnabled As Boolean = True
|
|
Public ReadOnly Property OptimizerManager_IsEnabled As Boolean
|
|
Get
|
|
Return m_OptimizerManager_IsEnabled
|
|
End Get
|
|
End Property
|
|
Friend Sub SetOptimizerManagerIsEnabled(bIsEnabled As Boolean)
|
|
m_OptimizerManager_IsEnabled = bIsEnabled
|
|
NotifyPropertyChanged(NameOf(OptimizerManager_IsEnabled))
|
|
End Sub
|
|
|
|
Friend Property CurrProj As ProjFileVM
|
|
Get
|
|
Return ProjectManagerVM.CurrProj
|
|
End Get
|
|
Set(value As ProjFileVM)
|
|
ProjectManagerVM.CurrProj = value
|
|
End Set
|
|
End Property
|
|
|
|
Friend Property CurrProd As ProdFileVM
|
|
Get
|
|
Return ProjectManagerVM.CurrProd
|
|
End Get
|
|
Set(value As ProdFileVM)
|
|
ProjectManagerVM.CurrProd = value
|
|
End Set
|
|
End Property
|
|
|
|
Private m_TempCurrProd As ProdFileVM
|
|
Friend Property TempCurrProd As ProdFileVM
|
|
Get
|
|
Return m_TempCurrProd
|
|
End Get
|
|
Set(value As ProdFileVM)
|
|
m_TempCurrProd = value
|
|
End Set
|
|
End Property
|
|
|
|
Friend m_MruFiles As New MruList
|
|
Public ReadOnly Property MruFileNames As ObservableCollection(Of String)
|
|
Get
|
|
Dim IdAndBTLFileNames As New ObservableCollection(Of String)
|
|
For Each FileName In m_MruFiles.FileNames.ToList()
|
|
Dim PdId As Integer = 0
|
|
Dim sPdId As String = Path.GetFileNameWithoutExtension(DirectCast(FileName, String).Replace("__", "_"))
|
|
Integer.TryParse(sPdId, PdId)
|
|
Dim PdFileM = DbControllers.m_ProdController.FindCoreByProdId(PdId)
|
|
If IsNothing(PdFileM) Then
|
|
m_MruFiles.Remove(FileName)
|
|
Else
|
|
Dim PdFileVM = New ProdFileVM(PdFileM)
|
|
IdAndBTLFileNames.Add(sPdId & " | " & PdFileVM.sName)
|
|
End If
|
|
Next
|
|
Return IdAndBTLFileNames
|
|
End Get
|
|
End Property
|
|
|
|
Private m_UpdateBTL_Visibility As Visibility = Visibility.Collapsed
|
|
Public Property UpdateBTL_Visibility As Visibility
|
|
Get
|
|
Return m_UpdateBTL_Visibility
|
|
End Get
|
|
Set(value As Visibility)
|
|
m_UpdateBTL_Visibility = value
|
|
End Set
|
|
End Property
|
|
|
|
Private m_AddProj_Visibility As Visibility
|
|
Public ReadOnly Property AddProj_Visibility As Visibility
|
|
Get
|
|
Return m_AddProj_Visibility
|
|
End Get
|
|
End Property
|
|
|
|
' indice ultimo progetto
|
|
Private m_nLastProdId As Integer
|
|
Friend ReadOnly Property nLastProdId As Integer
|
|
Get
|
|
Return m_nLastProdId
|
|
End Get
|
|
End Property
|
|
|
|
Public ReadOnly Property nProjType As BWType
|
|
Get
|
|
Return If(Not IsNothing(CurrProj), CurrProj.nType, BWType.NULL)
|
|
End Get
|
|
End Property
|
|
|
|
Public ReadOnly Property nProdType As BWType
|
|
Get
|
|
Return If(Not IsNothing(CurrProd), CurrProd.nType, BWType.NULL)
|
|
End Get
|
|
End Property
|
|
|
|
Private m_IsStartBtnOpen As Boolean = False
|
|
Public Property IsStartBtnOpen As Boolean
|
|
Get
|
|
Return m_IsStartBtnOpen
|
|
End Get
|
|
Set(value As Boolean)
|
|
m_IsStartBtnOpen = value
|
|
End Set
|
|
End Property
|
|
Friend Sub SetIsStartBtnOpen(bIsStartBtnOpen As Boolean)
|
|
m_IsStartBtnOpen = bIsStartBtnOpen
|
|
NotifyPropertyChanged(NameOf(IsStartBtnOpen))
|
|
End Sub
|
|
|
|
Private m_IsSaveBtnOpen As Boolean = False
|
|
Public Property IsSaveBtnOpen As Boolean
|
|
Get
|
|
Return m_IsSaveBtnOpen
|
|
End Get
|
|
Set(value As Boolean)
|
|
m_IsSaveBtnOpen = value
|
|
End Set
|
|
End Property
|
|
Friend Sub SetIsSaveBtnOpen(bIsSaveBtnOpen As Boolean)
|
|
m_IsSaveBtnOpen = bIsSaveBtnOpen
|
|
NotifyPropertyChanged(NameOf(IsSaveBtnOpen))
|
|
End Sub
|
|
|
|
Private m_IsBtlBtnOpen As Boolean = False
|
|
Public Property IsBtlBtnOpen As Boolean
|
|
Get
|
|
Return m_IsBtlBtnOpen
|
|
End Get
|
|
Set(value As Boolean)
|
|
m_IsBtlBtnOpen = value
|
|
End Set
|
|
End Property
|
|
Friend Sub SetIsBtlBtnOpen(bIsBtlBtnOpen As Boolean)
|
|
m_IsBtlBtnOpen = bIsBtlBtnOpen
|
|
NotifyPropertyChanged(NameOf(IsBtlBtnOpen))
|
|
End Sub
|
|
|
|
Private m_nListProjAsseBase As New Dictionary(Of Integer, Integer)
|
|
Public Property ListProjAsseBase As Dictionary(Of Integer, Integer)
|
|
Get
|
|
Return m_nListProjAsseBase
|
|
End Get
|
|
Set(value As Dictionary(Of Integer, Integer))
|
|
m_nListProjAsseBase = value
|
|
NotifyPropertyChanged(NameOf(ListProjAsseBase))
|
|
End Set
|
|
End Property
|
|
|
|
Private m_BtlImage As String = DOWN_IMAGE
|
|
Public ReadOnly Property BtlImage As String
|
|
Get
|
|
Return m_BtlImage
|
|
End Get
|
|
End Property
|
|
Friend Sub SetBtlImage(value As String)
|
|
m_BtlImage = value
|
|
NotifyPropertyChanged(NameOf(BtlImage))
|
|
End Sub
|
|
|
|
Private m_OpenImage As String = DOWN_IMAGE
|
|
Public ReadOnly Property OpenImage As String
|
|
Get
|
|
Return m_OpenImage
|
|
End Get
|
|
End Property
|
|
Friend Sub SetOpenImage(value As String)
|
|
m_OpenImage = value
|
|
NotifyPropertyChanged(NameOf(OpenImage))
|
|
End Sub
|
|
|
|
Private m_SaveImage As String = DOWN_IMAGE
|
|
Public ReadOnly Property SaveImage As String
|
|
Get
|
|
Return m_SaveImage
|
|
End Get
|
|
End Property
|
|
Friend Sub SetSaveImage(value As String)
|
|
m_SaveImage = value
|
|
NotifyPropertyChanged(NameOf(SaveImage))
|
|
End Sub
|
|
|
|
Private m_BTLDataWnd As BTLDataWndVM
|
|
Public ReadOnly Property BTLDataWnd As BTLDataWndVM
|
|
Get
|
|
Return m_BTLDataWnd
|
|
End Get
|
|
End Property
|
|
|
|
' Definizione comandi
|
|
Private m_cmdNew As ICommand
|
|
Private m_cmdOpen As ICommand
|
|
Private m_cmdOpenMruFile As ICommand
|
|
Private m_cmdSave As ICommand
|
|
Private m_cmdImportBTL As ICommand
|
|
Private m_cmdExportProject As ICommand
|
|
Private m_cmdImportProject As ICommand
|
|
Private m_cmdAddProj As ICommand
|
|
Private m_cmdAddBTL As ICommand
|
|
Private m_cmdShowPopUpStartBtnCmd As ICommand
|
|
Private m_cmdShowPopUpSaveBtnCmd As ICommand
|
|
Private m_cmdShowPopUpBtlBtnCmd As ICommand
|
|
|
|
#Region "ToolTip"
|
|
|
|
'Proprietà ToolTip
|
|
Public ReadOnly Property NewToolTip As String
|
|
Get
|
|
Return EgtMsg(30501)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property OpenToolTip As String
|
|
Get
|
|
Return EgtMsg(30502)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property SaveToolTip As String
|
|
Get
|
|
Return EgtMsg(30503)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property SaveAsToolTip As String
|
|
Get
|
|
Return EgtMsg(30504)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property ImportBTL_ToolTip As String
|
|
Get
|
|
Return EgtMsg(61840)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property ImportProject_ToolTip As String
|
|
Get
|
|
Return EgtMsg(61839)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property ExportProject_ToolTip As String
|
|
Get
|
|
Return EgtMsg(61838)
|
|
End Get
|
|
End Property
|
|
Public ReadOnly Property AddProj_ToolTip As String
|
|
Get
|
|
Return EgtMsg(61921)
|
|
End Get
|
|
End Property
|
|
|
|
#End Region ' ToolTip
|
|
|
|
#End Region ' Field & Properties
|
|
|
|
#Region "CONSTRUCTORS"
|
|
|
|
Sub New()
|
|
Map.SetRefProdManagerVM(Me)
|
|
' Leggo ultimo indice di progetto
|
|
m_nLastProdId = GetMainPrivateProfileInt(S_GENERAL, K_PROJSINDEX, 1)
|
|
' Impostazioni MruLists
|
|
m_MruFiles.Init(S_MRUPRODFILES, 8)
|
|
' leggo attivazione update btl
|
|
If GetMainPrivateProfileInt(S_GENERAL, K_UPDATEBTL, 0) > 0 Then UpdateBTL_Visibility = Visibility.Visible
|
|
|
|
' attivo bottone AddProj
|
|
If GetMainPrivateProfileInt(S_GENERAL, K_ADDPROJ, 0) = 1 Then
|
|
m_AddProj_Visibility = Visibility.Visible
|
|
Else
|
|
m_AddProj_Visibility = Visibility.Collapsed
|
|
End If
|
|
|
|
' imposto timer di apertura da ottimizzatore
|
|
m_OpenProj_Timer.Interval = TimeSpan.FromMilliseconds(500)
|
|
AddHandler m_OpenProj_Timer.Tick, AddressOf OpenProject_Tick
|
|
m_OpenProj_Timer.Start()
|
|
End Sub
|
|
|
|
#End Region ' Constructors
|
|
|
|
#Region "METHODS"
|
|
|
|
Public Function SetCurrProj(nProjId As Integer) As Boolean
|
|
Return ProjectManagerVM.SetCurrProj(nProjId)
|
|
End Function
|
|
|
|
Public Function UpdateCurrProj() As Boolean
|
|
Return SetCurrProj(CurrProj.nProjId)
|
|
End Function
|
|
|
|
Private Function InitNewProj(ByRef nProjId As Integer, ByRef sProjectDir As String, nType As BWType, Machine As String) As Boolean
|
|
' se non ho ricevuto numero progetto da sovrascrivere
|
|
If nProjId = 0 Then
|
|
' richiedo indice nuovo progetto
|
|
nProjId = DbControllers.m_ProjController.GetNextIndex(Map.refMainWindowVM.MainWindowM.GetKeyNumber())
|
|
End If
|
|
' salvo dati creazione progetto
|
|
DbControllers.m_ProjController.Update(New ProjModel() With {.ProjId = nProjId,
|
|
.DtCreated = DateTime.Now(),
|
|
.PType = nType,
|
|
.Machine = Machine})
|
|
Return True
|
|
End Function
|
|
|
|
Friend Function InitNewProd(ByRef nProjId As Integer, ByRef nProdId As Integer, ByRef sProjectDir As String) As Boolean
|
|
' richiedo indice nuovo progetto
|
|
nProdId = DbControllers.m_ProdController.GetNextIndex(nProjId, Map.refMainWindowVM.MainWindowM.GetKeyNumber())
|
|
If nProdId <= 0 Then Return False
|
|
sProjectDir = refMainWindowVM.MainWindowM.sProdsDir & "\" & nProdId.ToString("0000")
|
|
' creo cartella nuovo progetto
|
|
If Not Directory.Exists(sProjectDir) Then
|
|
Directory.CreateDirectory(sProjectDir)
|
|
Else
|
|
Dim di As New DirectoryInfo(sProjectDir)
|
|
For Each file As FileInfo In di.EnumerateFiles()
|
|
file.Delete()
|
|
Next
|
|
For Each dir As DirectoryInfo In di.EnumerateDirectories()
|
|
dir.Delete(True)
|
|
Next
|
|
End If
|
|
Return True
|
|
End Function
|
|
|
|
Public Function SetCurrProd(nProdId As Integer) As Boolean
|
|
Return ProjectManagerVM.SetCurrProd(nProdId)
|
|
End Function
|
|
|
|
Public Sub OpenProject_Tick()
|
|
If Not m_bOpenProj Then Return
|
|
m_bOpenProj = False
|
|
' recupero progetto da Id
|
|
Dim DbProject As ProdFileM = DbControllers.m_ProdController.FindCoreByProdId(m_nProjIdToOpen)
|
|
Dim ProjectVM As New ProdFileVM(DbProject)
|
|
' verifico se progetto modificato, e chiedo se salvare
|
|
If Not ProjFileVM.VerifyProjectModification(ProjectManagerVM.CurrProj, ProjectType.PROJ) Then Return
|
|
OpenProject(ProjectVM)
|
|
m_nProjIdToOpen = GDB_ID.NULL
|
|
End Sub
|
|
|
|
Private Function CreateNewProd(Optional bFromImportBtl As Boolean = True) As Boolean
|
|
' creo proj
|
|
Dim nProjId As Integer = 0
|
|
Dim sBTLFileName As String = ""
|
|
Dim nType As BWType = BWType.NULL
|
|
Dim Machine As MyMachine = Nothing
|
|
If bFromImportBtl Then
|
|
If Not CreateNewProj(Nothing, nProjId, sBTLFileName, nType, Machine) Then
|
|
EgtOutLog("Errore! Creazione nuovo prod fallita!")
|
|
Return False
|
|
End If
|
|
Else
|
|
If Not CreateNewEmptyProj(nProjId, nType, Machine) Then
|
|
EgtOutLog("Errore! Creazione nuovo prod vuoto fallita!")
|
|
Return False
|
|
End If
|
|
End If
|
|
' inizializzo nuovo progetto PROD
|
|
Dim nProdId As Integer = 0
|
|
Dim sProdDir As String = ""
|
|
If Not InitNewProd(nProjId, nProdId, sProdDir) Then
|
|
EgtOutLog("Errore! Impossibile creare nuovo progetto!")
|
|
Return False
|
|
End If
|
|
' setto il PType del Prod
|
|
DbControllers.m_ProdController.UpdatePType(nProdId, nType)
|
|
' setto la Macchina associata al Prod
|
|
DbControllers.m_ProdController.UpdateMachine(nProdId, Machine.Name)
|
|
' creo cartella per Proj
|
|
Dim sProjDirPath As String = sProdDir & "\Projs\" & nProjId.ToString("0000")
|
|
Try
|
|
Directory.CreateDirectory(sProjDirPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile creare cartella del Proj!")
|
|
End Try
|
|
' copio file importato
|
|
Dim sImportFileTempPath As String = Map.refMainWindowVM.MainWindowM.sTempDir & "\" & sBTLFileName
|
|
Dim sImportFileProdPath As String = sProjDirPath & "\" & sBTLFileName
|
|
If File.Exists(sImportFileTempPath) Then
|
|
Try
|
|
File.Copy(sImportFileTempPath, sImportFileProdPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile copiare il file importato nella cartella del progetto!")
|
|
End Try
|
|
Try
|
|
File.Delete(sImportFileTempPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile cancellare il file importato dalla cartella Temp!")
|
|
End Try
|
|
End If
|
|
' salvo il progetto
|
|
Dim sProdFileName As String = sProdDir & "\" & nProdId.ToString("0000") & ".nge"
|
|
If Not EgtSaveFile(sProdFileName, NGE.CMPTEXT) Then
|
|
'' elimino da DB
|
|
''DbControllers.m_ProdController.DeleteProd(nProdId, True)
|
|
EgtOutLog("Errore! Impossibile salvare il progetto!")
|
|
Return False
|
|
End If
|
|
' resetto stato new del proj
|
|
DbControllers.m_ProjController.ResetNew(nProjId)
|
|
' imposto currprod
|
|
SetCurrProd(nProdId)
|
|
' recupero indice di modifica progetto quando caricato
|
|
Dim CommIndex As Integer = -1
|
|
Dim ActiveSessionList As List(Of StatusMapModel) = DbControllers.m_StatusMapController.GetProd(m_SupervisorId)
|
|
For Each ActiveSession In ActiveSessionList
|
|
If Not IsNothing(ProjectManagerVM.CurrProd) AndAlso ActiveSession.ItemId = ProjectManagerVM.CurrProd.nProdId Then
|
|
CommIndex = ActiveSession.Index
|
|
End If
|
|
Next
|
|
' carico gruppi di lavorazione
|
|
Map.refProjectVM.MachGroupPanelVM = New MyMachGroupPanelVM(MyMachGroupPanelM.CreateMyMachGroupPanel(Map.refMachinePanelVM.MachineList.ToList()))
|
|
If IsNothing(Map.refProjectVM.MachGroupPanelVM) Then
|
|
If Not IsNothing(ProjectManagerVM.CurrProd) Then
|
|
OpenProject(ProjectManagerVM.CurrProd)
|
|
Else
|
|
NewProject()
|
|
End If
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62581), EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) 'Error opening file
|
|
EgtOutLog("Errore! Caricamento dei gruppi di lavorazione fallito!")
|
|
Return False
|
|
End If
|
|
' fisso indice sessione di comunicazione
|
|
If CommIndex > -1 Then
|
|
ProjectManagerVM.CurrProd.SetModificationIndex(CommIndex)
|
|
End If
|
|
' calcolo volumi pezzi
|
|
For Each Part In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
Part.CalcBTLPartVolume()
|
|
Next
|
|
Core.ViewPanelVM.UpdateBWType(nType)
|
|
' imposto macchina del progetto
|
|
Map.refMachinePanelVM.SelectedMachine = Map.refMachinePanelVM.MachineList.FirstOrDefault(Function(x) String.Equals(x.Name, ProjectManagerVM.CurrProd.sMachine, StringComparison.OrdinalIgnoreCase))
|
|
Map.refMachinePanelVM.SetSelMachineName(Map.refMachinePanelVM.SelectedMachine.Name)
|
|
Map.refMachinePanelVM.SetStrategyManagerIsChecked(True)
|
|
' aggiorno le colonne in base al tipo progetto
|
|
Map.refRawPartListVM.UpdateColumns(nType)
|
|
Map.refFeatureInPartInRawPartListVM.UpdateColumns(nType)
|
|
' gestisco visibilita' bottoni
|
|
Map.refProjectVM.SetOptimizePanel_Visibility(True)
|
|
' aggiorno lista possibili nesting
|
|
Map.refOptimizePanelVM.UpdateOriginTypeList(EgtGetFirstNameInGroup(GDB_ID.ROOT, "RawParts") <> GDB_ID.NULL)
|
|
' aggiorno visibilità bottone Muovi pezzi
|
|
Map.refRawPartManagerVM.UpdateMovePartInRawPartVisibility()
|
|
' carico lista macchine e macchina del progetto per il pulsante Reset Macchina del CALCPanel
|
|
Map.refCALCPanelVM.LoadMachineList()
|
|
Map.refPartManagerVM.LockVisibilityUpdate()
|
|
' seleziono primo pezzo
|
|
If Map.refProjectVM.BTLStructureVM.BTLPartVMList.Count > 0 Then
|
|
Map.refProjectVM.BTLStructureVM.SetSelBTLPart(Map.refProjectVM.BTLStructureVM.BTLPartVMList(0))
|
|
End If
|
|
'LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63006), 70, 100) ' Loading graphics
|
|
'LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTBTL)
|
|
' Ricavo il tipo di Warehouse settato nell'INI
|
|
Dim nDefault As Integer = 2
|
|
If GetMainPrivateProfileInt(S_WAREHOUSE, EgtBEAMWALL.Core.ConstIni.K_TYPE, nDefault) = WarehouseType.MEDIUM Then
|
|
' Se di tipo Medium confronto le Sezioni del BTL importato con quelle in Warehouse
|
|
WarehouseWndVM.UpdateSectionXMaterial()
|
|
End If
|
|
' aggiorno nome macchina in statusbar
|
|
Map.refMyStatusBarVM.RefreshMachName()
|
|
' Aggiorno titolo
|
|
Map.refMainWindowVM.UpdateTitle()
|
|
' Aggiungo a ButtonBuildingList i BTL
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Clear()
|
|
If m_nListProjAsseBase.Count > 0 Then
|
|
For Each ItemProd As Integer In ProjectManagerVM.CurrProd.nProjIdList
|
|
Dim TempProj As ProjFileM = DbControllers.m_ProjController.FindByProjIdConv(ItemProd)
|
|
If m_nListProjAsseBase.ContainsKey(ItemProd) Then
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Add(New ButtonBuildingItem(ItemProd, m_nListProjAsseBase(ItemProd), TempProj.sBTLFileName))
|
|
Else
|
|
EgtOutLog("Errore nListProjAsseBase non trovato: " & ItemProd)
|
|
End If
|
|
Next
|
|
End If
|
|
Return True
|
|
End Function
|
|
|
|
Private Function CreateNewProj(ProdFileVM As ProdFileVM, Optional ByRef nProjId As Integer = 0, Optional ByRef sBTLFileName As String = "", Optional ByRef nType As BWType = BWType.NULL, Optional ByRef Machine As MyMachine = Nothing) As Boolean
|
|
Dim sDir As String = String.Empty
|
|
GetMainPrivateProfileString(S_GENERAL, K_LASTIMPDIR, "", sDir)
|
|
' apro finestra scelta file
|
|
Dim sImportFilePath As String = ""
|
|
Dim BTLDlg As New Microsoft.Win32.OpenFileDialog() With {
|
|
.Title = EgtMsg(61840),
|
|
.DefaultExt = ".btl",
|
|
.Filter = "BTL (*.btl)|*.btl" &
|
|
"|BTLX (*.btlx)|*.btlx",
|
|
.InitialDirectory = If(Directory.Exists(sDir), sDir, ""),
|
|
.CheckFileExists = True,
|
|
.ValidateNames = True}
|
|
|
|
If BTLDlg.ShowDialog() Then
|
|
sImportFilePath = BTLDlg.FileName
|
|
Else
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
Return False
|
|
End If
|
|
Dim sProjDir As String = ""
|
|
' verifico se non e' tra i BTL gia' importati
|
|
sBTLFileName = Path.GetFileName(sImportFilePath)
|
|
Dim nAlreadyImported As Integer = DbControllers.m_ProjController.AlreadyImported(Path.GetFileNameWithoutExtension(sImportFilePath))
|
|
If nAlreadyImported > 0 Then
|
|
' recupero progetto con lo stesso nome
|
|
Dim ToDeleteProj As ProjFileM = DbControllers.m_ProjController.FindByProjIdConv(nAlreadyImported)
|
|
' se esiste gia' un'ottimizzazione
|
|
If ToDeleteProj.nProdId > 0 Then
|
|
Select Case EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(61942), EgtMsg(15003), MessageBoxButton.YesNo, MessageBoxImage.Information) ' BTL file already imported and optimized. Do you want to import it again?
|
|
Case MessageBoxResult.Yes
|
|
' lo importo, quindi non devo fare nulla
|
|
Case MessageBoxResult.No
|
|
Return False
|
|
End Select
|
|
End If
|
|
End If
|
|
' Disabilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = False
|
|
If IsNothing(ProdFileVM) Then
|
|
' se si ha una sola macchina disponibile (non BOTH) setto il progetto importato a quella macchina e al tipo progetto associato
|
|
' altrimenti apro il dialog per scegliere la macchina e il tipo progetto a cui settare il progetto importato
|
|
If Map.refMachinePanelVM.MachineList.Count = 1 AndAlso DirectCast(Map.refMachinePanelVM.MachineList(0), MyMachine).nType <> MachineType.BOTH Then
|
|
Machine = DirectCast(Map.refMachinePanelVM.MachineList(0), MyMachine)
|
|
nType = Machine.nType
|
|
Else
|
|
Dim ProjectTypeWndVM As New ProjectTypeWndVM()
|
|
Dim ProjectTypeWnd As New ProjectTypeWndV(Application.Current.MainWindow, ProjectTypeWndVM)
|
|
If ProjectTypeWnd.ShowDialog() Then
|
|
Machine = ProjectTypeWndVM.SelMachine
|
|
nType = ProjectTypeWndVM.nSelType
|
|
Else
|
|
Return False
|
|
End If
|
|
End If
|
|
'LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63008), EgtMsg(63009), 50) ' BTL file importing ' Reading BTL file
|
|
' creo progetto per file BTL
|
|
If Not CreateFirstBTLProj(sImportFilePath, nType, Machine, nProjId, sProjDir) Then Return False
|
|
Else
|
|
' creo progetto per file BTL
|
|
If Not AddNewBTLProj(sImportFilePath, ProdFileVM, nProjId, sProjDir) Then Return False
|
|
End If
|
|
' carico filtri di ricerca
|
|
Map.refProjectVM.BTLStructureVM.LoadFilters()
|
|
' gestisco log di importazione
|
|
ManageImportLog(nProjId, sProjDir)
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
'LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTBTL)
|
|
Return True
|
|
End Function
|
|
|
|
Private Function CreateFirstBTLProj(sImportFilePath As String, nType As BWType, Machine As MyMachine, ByRef nProjId As Integer, ByRef sProjDir As String) As Boolean
|
|
LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63008), EgtMsg(63009), 50) ' BTL file importing ' Reading BTL file
|
|
' copio file BTL
|
|
Dim sBtlCopyPath As String = Map.refMainWindowVM.MainWindowM.sTempDir & "\" & Path.GetFileName(sImportFilePath)
|
|
Dim bOk = False
|
|
Try
|
|
File.Copy(sImportFilePath, sBtlCopyPath, True)
|
|
bOk = True
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile copiare il file BTL!")
|
|
Return False
|
|
End Try
|
|
' inizializzo nuovo progetto
|
|
If Not InitNewProj(nProjId, sProjDir, nType, Machine.Name) Then
|
|
EgtOutLog("Errore! Impossibile creare indice nuovo progetto!")
|
|
' elimino file Btl copiato
|
|
Try
|
|
File.Delete(sBtlCopyPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Eliminazione file BTL copiato fallita!")
|
|
End Try
|
|
Return False
|
|
End If
|
|
' verifico tipo di file e recupero flag di importazione
|
|
Dim nFileType As Integer = EgtGetFileType(sBtlCopyPath)
|
|
If nFileType <> FT.BTL AndAlso nFileType <> FT.BTLX Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(10005), EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) ' File type unknown - Error
|
|
EgtOutLog("Errore! Estensione progetto sconosciuta!")
|
|
Return False
|
|
End If
|
|
Dim sBTLFlag As String
|
|
If nType = BWType.BEAM Then
|
|
sBTLFlag = K_BTLFLAG
|
|
Else
|
|
sBTLFlag = K_WALLBTLFLAG
|
|
End If
|
|
Dim nFlag As Integer = GetMainPrivateProfileInt(S_IMPORT, sBTLFlag, EIB_FL.TS3_POS + EIB_FL.SORT + EIB_FL.USEUATTR)
|
|
' importo file
|
|
If Not EgtNewFile() Then
|
|
EgtOutLog("Errore! Impossibile creare nuovo progetto!")
|
|
Return False
|
|
End If
|
|
Select Case nFileType
|
|
Case FT.BTL
|
|
If Not EgtImportBtl(sBtlCopyPath, nFlag) Then
|
|
EgtOutLog("Errore! Inserimento nel progetto del file BTL fallito!")
|
|
' elimino file Btl copiato
|
|
Try
|
|
File.Delete(sBtlCopyPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Eliminazione file BTL copiato fallita!")
|
|
End Try
|
|
' elimino da Db
|
|
' CheckMe impostata come cancellazione FISICA dal DB...
|
|
DbControllers.m_ProjController.DeleteProj(nProjId, False)
|
|
Return False
|
|
End If
|
|
Case FT.BTLX
|
|
If Not EgtImportBtlx(sBtlCopyPath, 0) Then
|
|
EgtOutLog("Errore! Inserimento nel progetto del file BTL fallito!")
|
|
' elimino file Btl copiato
|
|
Try
|
|
File.Delete(sBtlCopyPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Eliminazione file BTL copiato fallita!")
|
|
End Try
|
|
' elimino da Db
|
|
' CheckMe impostata come cancellazione FISICA dal DB...
|
|
DbControllers.m_ProjController.DeleteProj(nProjId, False)
|
|
Return False
|
|
End If
|
|
End Select
|
|
If EgtGetFirstPart() = GDB_ID.NULL Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62582), EgtMsg(15002), MessageBoxButton.OK, MessageBoxImage.Warning)
|
|
Return False
|
|
End If
|
|
|
|
' creo PROJECTINFO
|
|
Dim nProjectInfoLayer As Integer = EgtCreateGroup(GDB_ID.ROOT)
|
|
EgtSetName(nProjectInfoLayer, PROJECTINFO)
|
|
EgtSetLevel(nProjectInfoLayer, GDB_LV.SYSTEM)
|
|
' scrivo info proj e tipo su layer BtlInfo
|
|
EgtSetInfo(nProjectInfoLayer, BTL_PRT_PROJ, nProjId)
|
|
EgtSetInfo(nProjectInfoLayer, BTL_GEN_PROJTYPE, nType)
|
|
|
|
' imposto CurrentMachine
|
|
InitCurrentMachine(Machine)
|
|
' imposto flag secondo tipo di progetto (travi o pareti)
|
|
EgtBeamSetFlag(nFlag)
|
|
' LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 2, EgtMsg(63005), 50, 70) ' Loading parts
|
|
' aggiungo informazioni su pezzi
|
|
Dim nPartId As Integer = EgtGetFirstPart()
|
|
While nPartId <> GDB_ID.NULL
|
|
' scrivo in ogni pezzo ProjId
|
|
EgtSetInfo(nPartId, BTL_PRT_PROJ, nProjId)
|
|
nPartId = EgtGetNextPart(nPartId)
|
|
' scrivo Id negli outline
|
|
Dim nPRId As Integer = 1
|
|
Dim nOutlineLayer As Integer = EgtGetFirstNameInGroup(nPartId, OUTLINE)
|
|
If nOutlineLayer <> GDB_ID.NULL Then
|
|
Dim nOutlineId As Integer = EgtGetFirstInGroup(nOutlineLayer)
|
|
While nOutlineId <> GDB_ID.NULL
|
|
' verifico che sia feature
|
|
If EgtExistsInfo(nOutlineId, MGR_FTR_PRC) Then
|
|
EgtSetInfo(nOutlineId, MGR_FTR_PRID, nPRId)
|
|
nPRId += 1
|
|
End If
|
|
nOutlineId = EgtGetNext(nOutlineId)
|
|
End While
|
|
End If
|
|
End While
|
|
' scrivo info proj e type su layer BtlInfo
|
|
Dim nBTLInfoLayer As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, BTLINFO)
|
|
EgtSetInfo(nBTLInfoLayer, BTL_PRT_PROJ, nProjId)
|
|
EgtSetInfo(nBTLInfoLayer, BTL_GEN_PROJTYPE, nType)
|
|
' scrivo info proj su layer AsseBase
|
|
Dim nAsseBaseLayer As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, ASSEBASE)
|
|
EgtSetInfo(nAsseBaseLayer, BTL_PRT_PROJ, nProjId)
|
|
|
|
' Apro finestra parametri generali
|
|
Dim GeneralParametersWndVM As New GeneralParametersWndVM(nType)
|
|
|
|
' Controllo se la cartella AiSetUp è presente
|
|
GetFirstAiSetUp(nType)
|
|
|
|
Dim sDefaultConfigFile As String = String.Empty
|
|
If EgtUILib.GetPrivateProfileString(S_STRATEGY, K_DEFAULTCONFIG, "", sDefaultConfigFile, Map.refMainWindowVM.MainWindowM.sDefaultConfig) = 0 Then
|
|
SetFirstStrategy(GeneralParametersWndVM, sDefaultConfigFile)
|
|
End If
|
|
|
|
GeneralParametersWndVM.SetbSaveGeneralParameters(True)
|
|
GeneralParametersWndVM.SaveProjectParameters()
|
|
|
|
m_BTLDataWnd = New BTLDataWndVM(nType)
|
|
m_BTLDataWnd.Read(nType)
|
|
m_BTLDataWnd.SaveInfoBTL(nType)
|
|
|
|
SectionXMaterial.SetType(nType)
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 2, EgtMsg(63005), 50, 70) ' Loading parts
|
|
' leggo struttura BTL per liste
|
|
Map.refProjectVM.BTLStructureVM = New BTLStructureVM(BTLStructureM.CreateBTLStructure(0))
|
|
' aggiorno Db
|
|
Dim ExportDate As DateTime
|
|
Dim sBTLFileName As String = Path.GetFileNameWithoutExtension(sImportFilePath)
|
|
DateTime.TryParse(Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPDATE & " " &
|
|
Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPTIME, ExportDate)
|
|
DbControllers.m_ProjController.UpdateInfo(nProjId, sBTLFileName, sBTLFileName, Map.refProjectVM.BTLStructureVM.sLISTNAME, ExportDate, nType, Machine.Name)
|
|
CopyBuilding()
|
|
' se progetto pareti e vista ruotata
|
|
If nType = BWType.WALL AndAlso (CurrentMachine.ViewDir = VT.ISO_NW OrElse CurrentMachine.ViewDir = VT.ISO_NE) Then
|
|
' ruoto le pareti di 180 per raddrizzarle rispetto alla vista
|
|
For Each Wall In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
Wall.Rotation(True, Map.refProjectVM.BTLStructureVM.nPROJTYPE, True, 180, False)
|
|
Next
|
|
End If
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTBTL)
|
|
Return True
|
|
End Function
|
|
|
|
Private Function AddNewBTLProj(sImportFilePath As String, ProdFileVM As ProdFileVM, ByRef nProjId As Integer, ByRef sProjDir As String) As Boolean
|
|
'LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63008), EgtMsg(63009), 50) ' BTL file importing ' Reading BTL file
|
|
' inizializzo nuovo progetto
|
|
If Not InitNewProj(nProjId, sProjDir, ProdFileVM.nType, ProdFileVM.sMachine) Then
|
|
EgtOutLog("Errore! Impossibile creare indice nuovo progetto!")
|
|
Return False
|
|
End If
|
|
' creo cartella per Proj
|
|
Dim sProjDirPath As String = ProdFileVM.sProdDirPath & "\Projs\" & nProjId.ToString("0000")
|
|
Try
|
|
Directory.CreateDirectory(sProjDirPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile creare cartella del Proj!")
|
|
End Try
|
|
' copio file BTL
|
|
Dim sBtlCopyPath As String = sProjDirPath & "\" & Path.GetFileName(sImportFilePath)
|
|
Dim bOk = False
|
|
Try
|
|
File.Copy(sImportFilePath, sBtlCopyPath, True)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile copiare il file BTL!")
|
|
Return False
|
|
End Try
|
|
' verifico tipo di file e recupero flag di importazione
|
|
Dim nFileType As Integer = EgtGetFileType(sBtlCopyPath)
|
|
If nFileType <> FT.BTL AndAlso nFileType <> FT.BTLX Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(10005), EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) ' File type unknown - Error
|
|
EgtOutLog("Errore! Estensione progetto sconosciuta!")
|
|
Return False
|
|
End If
|
|
Dim sBTLFlag As String
|
|
If nType = BWType.BEAM Then
|
|
sBTLFlag = K_BTLFLAG
|
|
Else
|
|
sBTLFlag = K_WALLBTLFLAG
|
|
End If
|
|
Dim nFlag As Integer = GetMainPrivateProfileInt(S_IMPORT, sBTLFlag, EIB_FL.TS3_POS + EIB_FL.SORT + EIB_FL.USEUATTR)
|
|
' importo file
|
|
Dim nGroupQty As Integer = EgtGetGroupObjs(GDB_ID.ROOT)
|
|
Dim nLastPartId As Integer = EgtGetLastPart(GDB_ID.ROOT)
|
|
Select Case nFileType
|
|
Case FT.BTL
|
|
If Not EgtImportBtl(sBtlCopyPath, nFlag) Then
|
|
EgtOutLog("Errore! Inserimento nel progetto del file BTL fallito!")
|
|
' elimino file Btl copiato
|
|
Try
|
|
File.Delete(sBtlCopyPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Eliminazione file BTL copiato fallita!")
|
|
End Try
|
|
' elimino da Db
|
|
' CheckMe impostata come cancellazione FISICA dal DB...
|
|
DbControllers.m_ProjController.DeleteProj(nProjId, False)
|
|
Return False
|
|
End If
|
|
Case FT.BTLX
|
|
If Not EgtImportBtlx(sBtlCopyPath, 0) Then
|
|
EgtOutLog("Errore! Inserimento nel progetto del file BTL fallito!")
|
|
' elimino file Btl copiato
|
|
Try
|
|
File.Delete(sBtlCopyPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Eliminazione file BTL copiato fallita!")
|
|
End Try
|
|
' elimino da Db
|
|
' CheckMe impostata come cancellazione FISICA dal DB...
|
|
DbControllers.m_ProjController.DeleteProj(nProjId, False)
|
|
Return False
|
|
End If
|
|
End Select
|
|
' verifico che abbia importato qualcosa
|
|
If EgtGetGroupObjs(GDB_ID.ROOT) <= nGroupQty Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62582), EgtMsg(15002), MessageBoxButton.OK, MessageBoxImage.Warning)
|
|
Return False
|
|
End If
|
|
'LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 2, EgtMsg(63005), 50, 70) ' Loading parts
|
|
|
|
' creo PROJECTINFO
|
|
Dim nProjectInfoLayer As Integer = EgtCreateGroup(GDB_ID.ROOT)
|
|
EgtSetName(nProjectInfoLayer, PROJECTINFO)
|
|
EgtSetLevel(nProjectInfoLayer, GDB_LV.SYSTEM)
|
|
' scrivo info proj e tipo su layer BtlInfo
|
|
EgtSetInfo(nProjectInfoLayer, BTL_PRT_PROJ, nProjId)
|
|
EgtSetInfo(nProjectInfoLayer, BTL_GEN_PROJTYPE, nType)
|
|
|
|
' aggiungo informazioni su pezzi
|
|
Dim nPartId As Integer = EgtGetNextPart(nLastPartId)
|
|
While nPartId <> GDB_ID.NULL
|
|
' scrivo in ogni pezzo ProjId
|
|
EgtSetInfo(nPartId, BTL_PRT_PROJ, nProjId)
|
|
' scrivo Id negli outline
|
|
Dim nPRId As Integer = 1
|
|
Dim nOutlineLayer As Integer = EgtGetFirstNameInGroup(nPartId, OUTLINE)
|
|
If nOutlineLayer <> GDB_ID.NULL Then
|
|
Dim nOutlineId As Integer = EgtGetFirstInGroup(nOutlineLayer)
|
|
While nOutlineId <> GDB_ID.NULL
|
|
' verifico che sia feature
|
|
If EgtExistsInfo(nOutlineId, MGR_FTR_PRC) Then
|
|
EgtSetInfo(nOutlineId, MGR_FTR_PRID, nPRId)
|
|
nPRId += 1
|
|
End If
|
|
nOutlineId = EgtGetNext(nOutlineId)
|
|
End While
|
|
End If
|
|
nPartId = EgtGetNextPart(nPartId)
|
|
End While
|
|
' scrivo info proj e type su layer BtlInfo
|
|
Dim nBTLInfoLayer As Integer = EgtGetLastNameInGroup(GDB_ID.ROOT, BTLINFO)
|
|
EgtSetInfo(nBTLInfoLayer, BTL_PRT_PROJ, nProjId)
|
|
EgtSetInfo(nBTLInfoLayer, BTL_GEN_PROJTYPE, nType)
|
|
' scrivo info proj su layer AsseBase
|
|
Dim nAsseBaseLayer As Integer = EgtGetLastNameInGroup(GDB_ID.ROOT, ASSEBASE)
|
|
EgtSetInfo(nAsseBaseLayer, BTL_PRT_PROJ, nProjId)
|
|
|
|
' Apro finestra parametri generali
|
|
Dim GeneralParametersWndVM As New GeneralParametersWndVM(ProdFileVM.nType)
|
|
GeneralParametersWndVM.SetbSaveGeneralParameters(True)
|
|
GeneralParametersWndVM.SaveProjectParameters()
|
|
|
|
m_BTLDataWnd = New BTLDataWndVM()
|
|
m_BTLDataWnd.Read(nType)
|
|
m_BTLDataWnd.SaveInfoBTL(nType)
|
|
|
|
' leggo struttura BTL per liste
|
|
Map.refProjectVM.BTLStructureVM = New BTLStructureVM(BTLStructureM.CreateBTLStructure(0))
|
|
CopyBuilding()
|
|
Dim sProjFileName As String = sProjDir & "\" & nProjId.ToString("0000") & ".nge"
|
|
Dim bFirstPart As Boolean = EgtGetFirstPart() <> GDB_ID.NULL
|
|
If Not bOk Then
|
|
EgtOutLog("Errore nell'importazione BTL")
|
|
End If
|
|
' aggiorno Db
|
|
Dim ExportDate As DateTime
|
|
Dim sBTLFileName As String = Path.GetFileNameWithoutExtension(sImportFilePath)
|
|
DateTime.TryParse(Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPDATE & " " &
|
|
Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPTIME, ExportDate)
|
|
DbControllers.m_ProjController.UpdateInfo(nProjId, sBTLFileName, sBTLFileName, Map.refProjectVM.BTLStructureVM.sLISTNAME, ExportDate, ProdFileVM.nType, ProdFileVM.sMachine)
|
|
' salvo il progetto
|
|
Map.refSceneHostVM.SaveProject()
|
|
' riporto aggiunta proj a prod su Db
|
|
DbControllers.m_ProdController.AddProj(ProdFileVM.nProdId, nProjId)
|
|
' resetto stato new del proj
|
|
DbControllers.m_ProjController.ResetNew(nProjId)
|
|
' se progetto pareti e vista ruotata
|
|
If ProdFileVM.nType = BWType.WALL AndAlso (CurrentMachine.ViewDir = VT.ISO_NW OrElse CurrentMachine.ViewDir = VT.ISO_NE) Then
|
|
' ruoto le pareti di 180 per raddrizzarle rispetto alla vista
|
|
For Each Wall In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
Wall.Rotation(True, Map.refProjectVM.BTLStructureVM.nPROJTYPE, True, 180, False)
|
|
Next
|
|
End If
|
|
' calcolo volumi pezzi
|
|
For Each Part In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
Part.CalcBTLPartVolume()
|
|
Next
|
|
' Aggiungo a ButtonBuildingList i BTL
|
|
Dim TempProj As ProjFileM = DbControllers.m_ProjController.FindByProjIdConv(nProjId)
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Add(New ButtonBuildingItem(nProjId, m_nListProjAsseBase(nProjId), TempProj.sBTLFileName))
|
|
'LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63006), 70, 100) ' Loading graphics
|
|
' mostro tutti i pezzi
|
|
Map.refShowBeamPanelVM.ShowAll(True)
|
|
'LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTBTL)
|
|
Return True
|
|
End Function
|
|
|
|
Private Function CreateNewEmptyProj(ByRef nProjId As Integer, ByRef nType As BWType, ByRef Machine As MyMachine) As Boolean
|
|
Dim sProjDir As String = ""
|
|
' se si ha una sola macchina disponibile (non BOTH) setto il progetto importato a quella macchina e al tipo progetto associato
|
|
' altrimenti apro il dialog per scegliere la macchina e il tipo progetto a cui settare il progetto importato
|
|
If Map.refMachinePanelVM.MachineList.Count = 1 AndAlso DirectCast(Map.refMachinePanelVM.MachineList(0), MyMachine).nType <> MachineType.BOTH Then
|
|
Machine = DirectCast(Map.refMachinePanelVM.MachineList(0), MyMachine)
|
|
nType = Machine.nType
|
|
Else
|
|
Dim ProjectTypeWndVM As New ProjectTypeWndVM()
|
|
Dim ProjectTypeWnd As New ProjectTypeWndV(Application.Current.MainWindow, ProjectTypeWndVM)
|
|
If ProjectTypeWnd.ShowDialog() Then
|
|
Machine = ProjectTypeWndVM.SelMachine
|
|
nType = ProjectTypeWndVM.nSelType
|
|
Else
|
|
Return False
|
|
End If
|
|
End If
|
|
'LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63008), EgtMsg(63009), 50) ' BTL file importing ' Reading BTL file
|
|
' creo progetto vuoto
|
|
If Not CreateFirstEmptyProj(nType, Machine, nProjId, sProjDir) Then Return False
|
|
' carico filtri di ricerca
|
|
Map.refProjectVM.BTLStructureVM.LoadFilters()
|
|
'LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTBTL)
|
|
Return True
|
|
End Function
|
|
|
|
Private Function CreateFirstEmptyProj(nType As BWType, Machine As MyMachine, ByRef nProjId As Integer, ByRef sProjDir As String) As Boolean
|
|
'LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63008), EgtMsg(63009), 50) ' BTL file importing ' Reading BTL file
|
|
' inizializzo nuovo progetto
|
|
If Not InitNewProj(nProjId, sProjDir, nType, Machine.Name) Then
|
|
EgtOutLog("Errore! Impossibile creare indice nuovo progetto!")
|
|
Return False
|
|
End If
|
|
Dim sBTLFlag As String
|
|
If nType = BWType.BEAM Then
|
|
sBTLFlag = K_BTLFLAG
|
|
Else
|
|
sBTLFlag = K_WALLBTLFLAG
|
|
End If
|
|
' creo file
|
|
If Not EgtNewFile() Then
|
|
EgtOutLog("Errore! Impossibile creare nuovo progetto!")
|
|
Return False
|
|
End If
|
|
' Disabilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = False
|
|
|
|
' creo BTLINFO
|
|
Dim nBTLInfoLayer As Integer = EgtCreateGroup(GDB_ID.ROOT)
|
|
EgtSetName(nBTLInfoLayer, BTLINFO)
|
|
EgtSetLevel(nBTLInfoLayer, GDB_LV.SYSTEM)
|
|
|
|
' creo PROJECTINFO
|
|
Dim nProjectInfoLayer As Integer = EgtCreateGroup(GDB_ID.ROOT)
|
|
EgtSetName(nProjectInfoLayer, PROJECTINFO)
|
|
EgtSetLevel(nProjectInfoLayer, GDB_LV.SYSTEM)
|
|
' scrivo info proj e tipo su layer BtlInfo
|
|
EgtSetInfo(nProjectInfoLayer, BTL_PRT_PROJ, nProjId)
|
|
EgtSetInfo(nProjectInfoLayer, BTL_GEN_PROJTYPE, nType)
|
|
|
|
' imposto CurrentMachine
|
|
InitCurrentMachine(Machine)
|
|
' imposto flag secondo tipo di progetto (travi o pareti)
|
|
Dim nFlag As Integer = GetMainPrivateProfileInt(S_IMPORT, sBTLFlag, EIB_FL.TS3_POS + EIB_FL.SORT + EIB_FL.USEUATTR)
|
|
EgtBeamSetFlag(nFlag)
|
|
' LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 2, EgtMsg(63005), 50, 70) ' Loading parts
|
|
' aggiungo informazioni su pezzi
|
|
Dim nPartId As Integer = EgtGetFirstPart()
|
|
While nPartId <> GDB_ID.NULL
|
|
' scrivo in ogni pezzo ProjId
|
|
EgtSetInfo(nPartId, BTL_PRT_PROJ, nProjId)
|
|
nPartId = EgtGetNextPart(nPartId)
|
|
' scrivo Id negli outline
|
|
Dim nPRId As Integer = 1
|
|
Dim nOutlineLayer As Integer = EgtGetFirstNameInGroup(nPartId, OUTLINE)
|
|
If nOutlineLayer <> GDB_ID.NULL Then
|
|
Dim nOutlineId As Integer = EgtGetFirstInGroup(nOutlineLayer)
|
|
While nOutlineId <> GDB_ID.NULL
|
|
' verifico che sia feature
|
|
If EgtExistsInfo(nOutlineId, MGR_FTR_PRC) Then
|
|
EgtSetInfo(nOutlineId, MGR_FTR_PRID, nPRId)
|
|
nPRId += 1
|
|
End If
|
|
nOutlineId = EgtGetNext(nOutlineId)
|
|
End While
|
|
End If
|
|
End While
|
|
' scrivo info proj e type su layer BtlInfo
|
|
EgtSetInfo(nBTLInfoLayer, BTL_PRT_PROJ, nProjId)
|
|
EgtSetInfo(nBTLInfoLayer, BTL_GEN_PROJTYPE, nType)
|
|
' scrivo info proj su layer AsseBase
|
|
Dim nAsseBaseLayer As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, ASSEBASE)
|
|
EgtSetInfo(nAsseBaseLayer, BTL_PRT_PROJ, nProjId)
|
|
SectionXMaterial.SetType(nType)
|
|
|
|
' Apro finestra parametri generali
|
|
Dim GeneralParametersWndVM As New GeneralParametersWndVM(nType)
|
|
|
|
' Controllo se la cartella AiSetUp è presente
|
|
GetFirstAiSetUp(nType)
|
|
|
|
Dim sDefaultConfigFile As String = String.Empty
|
|
If EgtUILib.GetPrivateProfileString(S_STRATEGY, K_DEFAULTCONFIG, "", sDefaultConfigFile, Map.refMainWindowVM.MainWindowM.sDefaultConfig) = 0 Then
|
|
SetFirstStrategy(GeneralParametersWndVM, sDefaultConfigFile)
|
|
End If
|
|
|
|
GeneralParametersWndVM.SetbSaveGeneralParameters(True)
|
|
GeneralParametersWndVM.SaveProjectParameters()
|
|
|
|
m_BTLDataWnd = New BTLDataWndVM(nType)
|
|
m_BTLDataWnd.Read(nType)
|
|
m_BTLDataWnd.SaveInfoBTL(nType)
|
|
|
|
' leggo struttura BTL per liste
|
|
Map.refProjectVM.BTLStructureVM = New BTLStructureVM(BTLStructureM.CreateBTLStructure(0))
|
|
CopyBuilding()
|
|
' aggiorno Db
|
|
Dim ExportDate As DateTime
|
|
Dim sBTLFileName As String = " New - AEdifica"
|
|
DateTime.TryParse(Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPDATE & " " &
|
|
Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPTIME, ExportDate)
|
|
DbControllers.m_ProjController.UpdateInfo(nProjId, sBTLFileName, sBTLFileName, Map.refProjectVM.BTLStructureVM.sLISTNAME, ExportDate, nType, Machine.Name)
|
|
' aggiungo primo pezzo
|
|
Map.refProjectVM.BTLStructureVM.AddPart(nProjId)
|
|
' Aggiungo a ButtonBuildingList i BTL
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Clear()
|
|
If m_nListProjAsseBase.Count > 0 Then
|
|
Dim TempProj As ProjFileM = DbControllers.m_ProjController.FindByProjIdConv(nProjId)
|
|
If m_nListProjAsseBase.ContainsKey(nProjId) Then
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Add(New ButtonBuildingItem(nProjId, m_nListProjAsseBase(nProjId), TempProj.sBTLFileName))
|
|
Else
|
|
EgtOutLog("Errore nListProjAsseBase non trovato: " & nProjId)
|
|
End If
|
|
End If
|
|
Map.refMainWindowVM.UpdateTitle()
|
|
NotifyPropertyChanged(NameOf(MruFileNames))
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
Return True
|
|
End Function
|
|
|
|
Friend Function OpenProject(TempCurrPd As ProdFileVM) As Boolean
|
|
m_TempCurrProd = TempCurrPd
|
|
' Disabilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = False
|
|
Dim sFilePath As String = ""
|
|
' se la string è vuota
|
|
If IsNothing(TempCurrProd) Then
|
|
If GetMainPrivateProfileInt(S_GENERAL, K_PROJECTMODE, 0) = 1 Then
|
|
Dim OpenProdFileDialogVM As NewOpenProjectFileDialogVM = Nothing
|
|
' apro dialogo di scelta Prod
|
|
OpenProdFileDialogVM = New NewOpenProjectFileDialogVM
|
|
Dim OpenFile As New NewOpenProjectFileDialogV(Application.Current.MainWindow, OpenProdFileDialogVM)
|
|
Dim DialogResult As Boolean? = OpenFile.EgtShowDialog(ProjectType.PROD)
|
|
If IsNothing(DialogResult) OrElse Not DialogResult Then Return True
|
|
sFilePath = OpenProdFileDialogVM.SelProject.ProdFileVM.sProdPath
|
|
m_TempCurrProd = OpenProdFileDialogVM.SelProject.ProdFileVM
|
|
Else
|
|
Dim OpenProjectFileDialogVM As OpenProjectFileDialogVM = Nothing
|
|
' apro dialogo di scelta file
|
|
OpenProjectFileDialogVM = New OpenProjectFileDialogVM
|
|
Dim OpenFile As New OpenProjectFileDialogV(Application.Current.MainWindow, OpenProjectFileDialogVM)
|
|
Dim DialogResult As Boolean? = OpenFile.EgtShowDialog(ProjectType.PROD)
|
|
If IsNothing(DialogResult) OrElse Not DialogResult Then Return True
|
|
sFilePath = OpenProjectFileDialogVM.SelProject.sProdPath
|
|
m_TempCurrProd = OpenProjectFileDialogVM.SelProject
|
|
End If
|
|
Else
|
|
sFilePath = If(Not IsNothing(m_TempCurrProd.sProdPath), m_TempCurrProd.sProdPath, "")
|
|
End If
|
|
LoadingWndHelper.OpenLoadingWnd(ActiveIds.OPENPROD, 3, EgtMsg(63004), EgtMsg(63001), 50) ' Optimization opening ' Loading project geometries
|
|
If Not File.Exists(sFilePath) Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(61871))
|
|
EgtOutLog("Errore! File da aprire non trovato!")
|
|
Return False
|
|
End If
|
|
' se la macchina del progetto in apertura non è tra le macchine disponibili lo segnalo ed esco
|
|
Dim OpenProjectMachine As MyMachine = Map.refMachinePanelVM.MachineList.FirstOrDefault(Function(x) String.Equals(x.Name, m_TempCurrProd.sMachine, StringComparison.OrdinalIgnoreCase))
|
|
If IsNothing(OpenProjectMachine) Then
|
|
' rimuovo il file in apertura dalla lista degli MRU
|
|
m_MruFiles.Remove(sFilePath)
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(61885), EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) 'Error
|
|
EgtOutLog("Errore! Macchina del progetto da aprire non trovata!")
|
|
Return False
|
|
End If
|
|
' apro il file
|
|
If Not EgtOpenFile(sFilePath) Then
|
|
m_MruFiles.Remove(sFilePath)
|
|
If Not IsNothing(ProjectManagerVM.CurrProd) AndAlso sFilePath <> ProjectManagerVM.CurrProd.sProdPath Then
|
|
OpenProject(ProjectManagerVM.CurrProd)
|
|
Else
|
|
NewProject()
|
|
End If
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(10003) & " '" & sFilePath & "'", EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) 'Error opening file
|
|
EgtOutLog("Errore! Caricamento del progetto fallito!")
|
|
Return False
|
|
End If
|
|
' imposto CurrentMachine
|
|
InitCurrentMachine(OpenProjectMachine)
|
|
SectionXMaterial.SetType(TempCurrProd.nType)
|
|
' Procedo a seconda del risultato
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.OPENPROD, 2, EgtMsg(63005), 50, 70) ' Loading part list
|
|
|
|
' leggo struttura BTL
|
|
Map.refProjectVM.BTLStructureVM = New BTLStructureVM(BTLStructureM.CreateBTLStructure(0))
|
|
|
|
CopyBuilding()
|
|
|
|
' Controllo se ci sono strategie forzate
|
|
ForcedStrategy(Map.refProjectVM.BTLStructureVM.BTLPartVMList)
|
|
|
|
If IsNothing(Map.refProjectVM.BTLStructureVM) Then
|
|
m_MruFiles.Remove(sFilePath)
|
|
If Not IsNothing(ProjectManagerVM.CurrProd) AndAlso sFilePath <> ProjectManagerVM.CurrProd.sProdPath Then
|
|
OpenProject(ProjectManagerVM.CurrProd)
|
|
Else
|
|
NewProject()
|
|
End If
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(10003) & " '" & sFilePath & "'", EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) 'Error opening file
|
|
EgtOutLog("Errore! Caricamento dei pezzi btl fallito!")
|
|
Return False
|
|
End If
|
|
' imposto progetto corrente
|
|
Dim OldProd As ProdFileVM = ProjectManagerVM.CurrProd
|
|
ProjectManagerVM.CurrProd = TempCurrProd
|
|
m_BTLDataWnd = New BTLDataWndVM()
|
|
DbControllers.m_ProdController.LockByProdId(ProjectManagerVM.CurrProd.nProdId, True, Map.refMainWindowVM.MainWindowM.GetKeyNumber())
|
|
' recupero indice di modifica progetto quando caricato
|
|
Dim CommIndex As Integer = -1
|
|
Dim ActiveSessionList As List(Of StatusMapModel) = DbControllers.m_StatusMapController.GetProd(m_SupervisorId)
|
|
For Each ActiveSession In ActiveSessionList
|
|
If Not IsNothing(ProjectManagerVM.CurrProd) AndAlso ActiveSession.ItemId = ProjectManagerVM.CurrProd.nProdId Then
|
|
CommIndex = ActiveSession.Index
|
|
End If
|
|
Next
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.OPENPROD, 3, EgtMsg(63002), 70, 100) ' Loading machining groups
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.GOTOPROD, 3, EgtMsg(63002), 50, 100) ' Loading machining groups
|
|
' carico gruppi di lavorazione
|
|
Map.refProjectVM.MachGroupPanelVM = New MyMachGroupPanelVM(MyMachGroupPanelM.CreateMyMachGroupPanel(Map.refMachinePanelVM.MachineList.ToList()))
|
|
If IsNothing(Map.refProjectVM.MachGroupPanelVM) Then
|
|
m_MruFiles.Remove(sFilePath)
|
|
If Not IsNothing(OldProd) AndAlso sFilePath <> OldProd.sProdPath Then
|
|
OpenProject(OldProd)
|
|
Else
|
|
NewProject()
|
|
End If
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(10003) & " '" & sFilePath & "'", EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) 'Error opening file
|
|
EgtOutLog("Errore! Caricamento dei gruppi di lavorazione fallito!")
|
|
Return False
|
|
End If
|
|
' imposto flag secondo tipo di progetto (travi o pareti)
|
|
Dim sBTLFlag As String = If(m_TempCurrProd.nType = Core.ConstBeam.BWType.BEAM, K_BTLFLAG, K_WALLBTLFLAG)
|
|
Dim nFlag As Integer = GetMainPrivateProfileInt(S_IMPORT, sBTLFlag, EIB_FL.TS3_POS + EIB_FL.SORT + EIB_FL.USEUATTR)
|
|
EgtBeamSetFlag(nFlag)
|
|
' fisso indice sessione di comunicazione
|
|
If CommIndex > -1 Then
|
|
ProjectManagerVM.CurrProd.SetModificationIndex(CommIndex)
|
|
End If
|
|
' verifico se volume pezzi calcolato
|
|
Dim bIsCalculated As Boolean = False
|
|
For Each BTLPart In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
If BTLPart.BTLPartM.dVolume > 0 Then Continue For
|
|
bIsCalculated = True
|
|
BTLPart.CalcBTLPartVolume()
|
|
Next
|
|
If bIsCalculated Then
|
|
Dim CurrProject As String = ""
|
|
EgtGetCurrFilePath(CurrProject)
|
|
EgtSaveFile(CurrProject, NGE.CMPTEXT)
|
|
End If
|
|
' se salvato, carico progetto in lista mru
|
|
If Not Map.refProdManagerVM.TempCurrProd.bIsNew Then
|
|
m_MruFiles.Add(sFilePath)
|
|
End If
|
|
' carico filtri di ricerca
|
|
Map.refProjectVM.BTLStructureVM.LoadFilters()
|
|
' imposto macchina del progetto
|
|
Map.refMachinePanelVM.SelectedMachine = Map.refMachinePanelVM.MachineList.FirstOrDefault(Function(x) String.Equals(x.Name, ProjectManagerVM.CurrProd.sMachine, StringComparison.OrdinalIgnoreCase))
|
|
Map.refMachinePanelVM.SetSelMachineName(Map.refMachinePanelVM.SelectedMachine.Name)
|
|
Map.refMachinePanelVM.SetStrategyManagerIsChecked(True)
|
|
Core.ViewPanelVM.UpdateBWType(ProjectManagerVM.CurrProd.nType)
|
|
' aggiorno le colonne in base al tipo progetto
|
|
Map.refRawPartListVM.UpdateColumns(ProjectManagerVM.CurrProd.nType)
|
|
Map.refFeatureInPartInRawPartListVM.UpdateColumns(ProjectManagerVM.CurrProd.nType)
|
|
' gestisco visibilita' bottoni
|
|
Map.refProjectVM.SetOptimizePanel_Visibility(True)
|
|
' aggiorno lista possibili nesting
|
|
Map.refOptimizePanelVM.UpdateOriginTypeList(EgtGetFirstNameInGroup(GDB_ID.ROOT, "RawParts") <> GDB_ID.NULL)
|
|
' aggiorno visibilità bottone Muovi pezzi
|
|
Map.refRawPartManagerVM.UpdateMovePartInRawPartVisibility()
|
|
' carico lista macchine e macchina del progetto per il pulsante Reset Macchina del CALCPanel
|
|
Map.refCALCPanelVM.LoadMachineList()
|
|
' seleziono primo pezzo
|
|
If Map.refProjectVM.BTLStructureVM.BTLPartVMList.Count > 0 Then
|
|
Map.refProjectVM.BTLStructureVM.SetSelBTLPart(Map.refProjectVM.BTLStructureVM.BTLPartVMList(0))
|
|
End If
|
|
' aggiorno titolo
|
|
Map.refMainWindowVM.UpdateTitle()
|
|
' refresh lista mru
|
|
NotifyPropertyChanged(NameOf(MruFileNames))
|
|
' aggiorno nome macchina in statusbar
|
|
Map.refMyStatusBarVM.RefreshMachName()
|
|
' Controllo se ci sono strategie modificate nei pezzi e mostro l'immagine della penna
|
|
ModifyStrategyInfo(Map.refProjectVM.BTLStructureVM.BTLPartVMList)
|
|
' Aggiungo a ButtonBuildingList i BTL
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Clear()
|
|
If m_nListProjAsseBase.Count > 0 Then
|
|
For Each ItemProd As Integer In ProjectManagerVM.CurrProd.nProjIdList
|
|
Dim TempProj As ProjFileM = DbControllers.m_ProjController.FindByProjIdConv(ItemProd)
|
|
If m_nListProjAsseBase.ContainsKey(ItemProd) Then
|
|
Map.refSceneBuildingVM.ButtonBuildingList.Add(New ButtonBuildingItem(ItemProd, m_nListProjAsseBase(ItemProd), TempProj.sBTLFileName))
|
|
Else
|
|
EgtOutLog("Errore nListProjAsseBase non trovato: " & ItemProd)
|
|
End If
|
|
Next
|
|
End If
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.OPENPROD)
|
|
Return True
|
|
End Function
|
|
|
|
Public Function Save(Optional bShowLoading As Boolean = False) As Boolean
|
|
If IsNothing(CurrProd) Then Return False
|
|
If bShowLoading Then LoadingWndHelper.OpenLoadingWnd(ActiveIds.SAVEPROD, 2, EgtMsg(63007), EgtMsg(63012), 70) ' Project saving ' Saving geometry
|
|
If Not Map.refSceneHostVM.SaveProject() Then
|
|
m_MruFiles.Remove(CurrProd.sProdPath)
|
|
Dim sMsg As String = EgtMsg(10004) & " '" & CurrProd.sProdPath & "'" 'Error saving file
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, sMsg, EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) ' Error
|
|
EgtOutLog("Salvataggio progetto non riuscito")
|
|
Return False
|
|
End If
|
|
If bShowLoading Then LoadingWndHelper.UpdateLoadingWnd(ActiveIds.SAVEPROD, 2, EgtMsg(63013), 70, 100) ' Saving data on Db
|
|
' aggiorno pezzi su Db
|
|
Dim MyMachGroupList As New List(Of MyMachGroupM)
|
|
If Not IsNothing(Map.refProjectVM.MachGroupPanelVM) Then
|
|
For Each MachGroup In Map.refProjectVM.MachGroupPanelVM.m_MyMachGroupPanelM.MachGroupMList
|
|
MyMachGroupList.Add(MachGroup)
|
|
Next
|
|
End If
|
|
' aggiorno BTLParts su DB
|
|
For Each ProjId In CurrProd.nProjIdList
|
|
Dim ProjIdPartList As IEnumerable(Of BTLPartM) = Map.refProjectVM.BTLStructureVM.BTLStructureM.BTLPartMList.Where(Function(x) x.m_nPROJ = ProjId)
|
|
If Not IsNothing(ProjIdPartList) Then
|
|
DbControllers.m_ProjController.UpdateBtlParts(ProjId, ProjIdPartList.ToList())
|
|
End If
|
|
Next
|
|
If Not DbControllers.m_ProdController.UpdateMachGroup(CurrProd.nProdId, MyMachGroupList) And bShowLoading Then
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.SAVEPROD)
|
|
Return False
|
|
End If
|
|
' verifico se Reset Macchina modificato e nel caso aggiorno DB e CurrProj
|
|
If Map.refCALCPanelVM.IsMachineModified() Then
|
|
DbControllers.m_ProdController.UpdateMachine(CurrProd.nProdId, Map.refCALCPanelVM.SelectedMachine.Name)
|
|
CurrProd.SetMachine(Map.refCALCPanelVM.SelectedMachine.Name)
|
|
' ciclo sulla lista di ProjId associati
|
|
For Each ProjId In CurrProd.nProjIdList
|
|
' aggiorno la Macchina per i ProjId associati sul DB
|
|
DbControllers.m_ProjController.UpdateMachine(ProjId, Map.refCALCPanelVM.SelectedMachine.Name)
|
|
' se uno dei Proj interessati equivale al Proj correntemente aperto setto la Macchina dello stesso
|
|
' (poichè il progetto corrente non viene riaperto e riletto dal DB)
|
|
If ProjId = CurrProd.nProdId Then CurrProd.SetMachine(Map.refCALCPanelVM.SelectedMachine.Name)
|
|
Next
|
|
Map.refCALCPanelVM.ResetMachineModified()
|
|
' aggiorno nome macchina in statusbar
|
|
Map.refMyStatusBarVM.RefreshMachName()
|
|
End If
|
|
' se nuovo progetto
|
|
If CurrProd.bIsNew Then
|
|
' resetto stato new
|
|
CurrProd.bIsNew = False
|
|
Else
|
|
' Aggiungo file a lista Mru
|
|
m_MruFiles.Add(CurrProd.sProdPath)
|
|
End If
|
|
Map.refMainWindowVM.UpdateTitle()
|
|
NotifyPropertyChanged(NameOf(MruFileNames))
|
|
If bShowLoading Then LoadingWndHelper.CloseLoadingWnd(ActiveIds.SAVEPROD)
|
|
Return True
|
|
End Function
|
|
|
|
Private Sub ManageImportLog(nProjId As Integer, sProjDir As String)
|
|
Dim LogFile As New List(Of String)
|
|
Using FileStream As New FileStream(Map.refMainWindowVM.MainWindowM.sLogFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
|
|
Dim StreamReader As New StreamReader(FileStream)
|
|
Dim Line As String = StreamReader.ReadLine()
|
|
While Not StreamReader.EndOfStream
|
|
Line = StreamReader.ReadLine()
|
|
LogFile.Add(Line)
|
|
End While
|
|
StreamReader.Close()
|
|
End Using
|
|
If LogFile.Count > 0 Then
|
|
' recupero ultima occorrenza di import
|
|
Dim sLastImport As String = LogFile.LastOrDefault(Function(x) x.Contains("ImportBtl"))
|
|
' verifico linee successive
|
|
Dim nLastImportIndex As Integer = -1
|
|
If Not String.IsNullOrWhiteSpace(sLastImport) Then
|
|
nLastImportIndex = LogFile.IndexOf(sLastImport)
|
|
End If
|
|
Dim sImportMessage As String = sLastImport & Environment.NewLine
|
|
Dim sImportLog As New List(Of String)({sLastImport})
|
|
If nLastImportIndex > 0 Then
|
|
Dim bGlobalError As Boolean = False
|
|
' ciclo sulle righe successive
|
|
For Index = nLastImportIndex + 1 To LogFile.Count - 1
|
|
Dim sLogLine As String = LogFile(Index).Trim()
|
|
' verifico se fanno parte dell'import
|
|
Dim bStartWithError As Boolean = sLogLine.StartsWith("Error")
|
|
Dim bStartWithInfo As Boolean = sLogLine.StartsWith("Info")
|
|
If Not bStartWithError And Not bStartWithInfo Then Exit For
|
|
If bStartWithError Then
|
|
If Not bGlobalError Then bGlobalError = True
|
|
sImportMessage &= sLogLine & Environment.NewLine
|
|
End If
|
|
sImportLog.Add(sLogLine)
|
|
Next
|
|
' salvo file ImportLog nel progetto
|
|
Try
|
|
File.WriteAllLines(sProjDir & "\" & nProjId.ToString("0000") & "-ImportLog.txt", sImportLog)
|
|
Catch ex As Exception
|
|
'
|
|
End Try
|
|
' se almeno un errore, mostro log
|
|
If bGlobalError Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, sImportMessage, EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) ' Error
|
|
End If
|
|
End If
|
|
End If
|
|
End Sub
|
|
|
|
Public Sub OpenProjectFromSupervisor(ProjIdToOpen As Integer)
|
|
If (Not IsNothing(ProjectManagerVM.CurrProd) AndAlso ProjIdToOpen <> ProjectManagerVM.CurrProd.nProdId) OrElse Map.refMainMenuVM.SelPage <> Pages.OPTIMIZERPAGE Then
|
|
m_nProjIdToOpen = ProjIdToOpen
|
|
m_bOpenProj = True
|
|
End If
|
|
End Sub
|
|
|
|
''' <summary>
|
|
''' Funzione che copia i pezzi
|
|
''' </summary>
|
|
Friend Sub CopyBuilding()
|
|
Map.refSceneShowBuldingVM.MapInfo.Clear()
|
|
m_nListProjAsseBase.Clear()
|
|
|
|
Dim nRef As Integer = 0
|
|
|
|
Dim nListAsseBase As New ObservableCollection(Of Integer)
|
|
|
|
' Setto il nuovo contesto
|
|
EgtSetCurrentContext(Map.refSceneShowBuldingVM.SceneShowBulding.GetCtx())
|
|
' Creo nuovo file
|
|
EgtNewFile()
|
|
|
|
' Ritorno al contesto corrente
|
|
EgtSetCurrentContext(Map.refSceneHostVM.MainScene.GetCtx())
|
|
|
|
' Ciclo sull'asse base e lo copio nel nuovo contesto
|
|
Dim nAsseBaseLayerId As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, ASSEBASE)
|
|
While nAsseBaseLayerId <> GDB_ID.NULL
|
|
Dim nAsseBaseID As Integer = EgtCopyEx(Map.refSceneHostVM.MainScene.GetCtx(), nAsseBaseLayerId, Map.refSceneShowBuldingVM.SceneShowBulding.GetCtx(), nRef)
|
|
nListAsseBase.Add(nAsseBaseID)
|
|
nAsseBaseLayerId = EgtGetNextName(nAsseBaseLayerId, ASSEBASE)
|
|
End While
|
|
|
|
' Ciclo sui pezzi e li copio nel nuovo contesto
|
|
Dim nPartLayerId As Integer = EgtGetFirstPart()
|
|
While nPartLayerId <> GDB_ID.NULL
|
|
Dim nNewId As Integer = EgtCopyEx(Map.refSceneHostVM.MainScene.GetCtx(), nPartLayerId, Map.refSceneShowBuldingVM.SceneShowBulding.GetCtx(), nRef)
|
|
' Salvo le info dei pezzi per associarli in modo corretto
|
|
If nNewId > 0 AndAlso Not Map.refSceneShowBuldingVM.MapInfo.ContainsKey(nPartLayerId) Then
|
|
Map.refSceneShowBuldingVM.MapInfo.Add(nPartLayerId, nNewId)
|
|
End If
|
|
nPartLayerId = EgtGetNextPart(nPartLayerId)
|
|
End While
|
|
|
|
' Setto il nuovo contesto
|
|
EgtSetCurrentContext(Map.refSceneShowBuldingVM.SceneShowBulding.GetCtx())
|
|
|
|
' Ciclo sull'assebase e sostitusco '!SOU' con la vecchia info salvata in MapInfo
|
|
For IdAsseBase As Integer = 0 To nListAsseBase.Count - 1
|
|
Dim nIdF As Integer = EgtGetFirstInGroup(nListAsseBase(IdAsseBase))
|
|
While nIdF <> GDB_ID.NULL
|
|
Dim Sou As Integer = 0
|
|
EgtGetInfo(nIdF, "!SOU", Sou)
|
|
If EgtGetInfo(nIdF, "!SOU", Sou) AndAlso Map.refSceneShowBuldingVM.MapInfo.ContainsKey(Sou) Then
|
|
EgtSetInfo(nIdF, "!SOU", Map.refSceneShowBuldingVM.MapInfo(Sou))
|
|
End If
|
|
nIdF = EgtGetNext(nIdF)
|
|
End While
|
|
Map.refProjectVM.BTLStructureVM.ShowBuilding(nListAsseBase(IdAsseBase), True)
|
|
If IdAsseBase > 0 Then EgtSetStatus(nListAsseBase(IdAsseBase), GDB_ST.OFF)
|
|
Dim nProj As Integer = 0
|
|
If EgtGetInfo(nListAsseBase(IdAsseBase), PROJ, nProj) AndAlso Not m_nListProjAsseBase.ContainsKey(nProj) Then
|
|
m_nListProjAsseBase.Add(nProj, nListAsseBase(IdAsseBase))
|
|
End If
|
|
Next
|
|
|
|
EgtZoom(ZM.ALL)
|
|
|
|
' Ritorno al contesto corrente
|
|
EgtSetCurrentContext(Map.refSceneHostVM.MainScene.GetCtx())
|
|
End Sub
|
|
|
|
Private Sub ForcedStrategy(BTLPartVMList As ObservableCollection(Of BTLPartVM))
|
|
' Mostro le strategie forzate
|
|
Dim bValue As Boolean = False
|
|
Dim bValueForced As Boolean = False
|
|
For Each BTLPartParam As BTLPartVM In BTLPartVMList
|
|
For Each FeatureParam As BTLFeatureVM In BTLPartParam.BTLFeatureVMList
|
|
bValue = False
|
|
EgtGetInfo(FeatureParam.nFeatureId, ConstBeam.STRATEGY & FeatureParam.nFeatureId & "_FORCED", bValue)
|
|
If bValue Then
|
|
BTLPartParam.SetStrategyModify_Visibility(True)
|
|
FeatureParam.SetbStrategy_Visibility(True)
|
|
End If
|
|
For Each StrategySetupParam As StrategySetup In Map.refStrategyManagerVM.StrategySetupList
|
|
For Each StrategyFeatureParam As StrategyFeature In StrategySetupParam.StrategyFeatureList
|
|
For Each TopologyParam As Topology In StrategyFeatureParam.TopologyList
|
|
For Each StrategyParam As Strategy In TopologyParam.StrategyList
|
|
For Each Param As StrategyParameter In StrategyParam.ParameterList
|
|
bValueForced = False
|
|
EgtGetInfo(FeatureParam.nFeatureId, StrategyParam.sStrategyId & "_" & Param.sNameNge & "_FORCED", bValueForced)
|
|
If bValueForced Then FeatureParam.SetbStrategy_Visibility(True)
|
|
Next
|
|
Next
|
|
Next
|
|
Next
|
|
Next
|
|
Next
|
|
Next
|
|
End Sub
|
|
|
|
Private Sub ModifyStrategyInfo(BTLPartVMList As ObservableCollection(Of BTLPartVM))
|
|
Dim sStrategiesDirPath As String = Map.refMainWindowVM.MainWindowM.GetStrategiesDirPath(Map.refStrategyManagerVM.SelStrategyType.Id)
|
|
Dim sGeneralParametersFilePath As String = sStrategiesDirPath & "\" & GENERALPARAMETERS_FILE & ".json"
|
|
If File.Exists(sGeneralParametersFilePath) Then
|
|
Dim sReadedFiles As String = File.ReadAllText(sGeneralParametersFilePath)
|
|
Dim JsonGeneralParametersList As List(Of JsonGeneralParameters) = JsonConvert.DeserializeObject(Of List(Of JsonGeneralParameters))(sReadedFiles)
|
|
Map.refProjectVM.GeneralParametersList = New ObservableCollection(Of ProjectParameters)((From JsonGeneralParameter In JsonGeneralParametersList
|
|
Select JsonGeneralParameter.Deserialize(Map.refStrategyManagerVM.SelStrategyType.Id)).ToList())
|
|
End If
|
|
|
|
Dim bValuePart As Boolean = False
|
|
For Each PartItem As BTLPartVM In BTLPartVMList
|
|
For Each GeneralParam As ProjectParameters In Map.refProjectVM.GeneralParametersList
|
|
bValuePart = False
|
|
EgtGetInfo(PartItem.nPartId, GeneralParam.sNameNge & "_FORCED", bValuePart)
|
|
If bValuePart Then PartItem.SetStrategyModify_Visibility(True)
|
|
Next
|
|
Next
|
|
NotifyPropertyChanged(NameOf(Map.refProjectVM.GeneralParametersList))
|
|
End Sub
|
|
|
|
Private Sub GetFirstAiSetUp(nType As BWType)
|
|
Dim sAISetUpDir As String = String.Empty
|
|
If nType = BWType.BEAM Then
|
|
sAISetUpDir = Map.refMainWindowVM.MainWindowM.sMachinesRoot & "\" & CurrentMachine.sMachineName & "\" & BEAM_DIR & "\" & AISETUP_DIR
|
|
ElseIf nType = BWType.WALL Then
|
|
sAISetUpDir = Map.refMainWindowVM.MainWindowM.sMachinesRoot & "\" & CurrentMachine.sMachineName & "\" & WALL_DIR & "\" & AISETUP_DIR
|
|
End If
|
|
' Controllo se la cartella AISetup è presente
|
|
If Not Directory.Exists(sAISetUpDir) Then
|
|
' Se non esiste, la crea
|
|
Directory.CreateDirectory(sAISetUpDir)
|
|
End If
|
|
End Sub
|
|
|
|
''' <summary>
|
|
''' Funzione che scrive il file json di default se non è presente un file di configurazione
|
|
''' </summary>
|
|
''' <param name="GeneralParametersWndVM"></param>
|
|
Private Sub SetFirstStrategy(GeneralParametersWndVM As GeneralParametersWndVM, sDefaultConfigFile As String)
|
|
sDefaultConfigFile = "DefaultConfig"
|
|
Dim Strategy As New StrategySetup(sDefaultConfigFile)
|
|
Map.refStrategyManagerVM.SelStrategySetup = Strategy
|
|
Map.refStrategyManagerVM.StrategySetupList.Add(Strategy)
|
|
Map.refStrategyManagerVM.SelStrategySetup.Write(GeneralParametersWndVM.GeneralParametersList, True)
|
|
Map.refStrategyManagerVM.SetDefaultConfig_IsChecked(True)
|
|
EgtUILib.WritePrivateProfileString(S_STRATEGY, K_DEFAULTCONFIG, sDefaultConfigFile, Map.refMainWindowVM.MainWindowM.sDefaultConfig)
|
|
End Sub
|
|
|
|
#End Region ' Methods
|
|
|
|
#Region "COMMANDS"
|
|
|
|
#Region "New"
|
|
|
|
Public ReadOnly Property New_Command As ICommand
|
|
Get
|
|
If m_cmdNew Is Nothing Then
|
|
m_cmdNew = New Command(AddressOf NewProject)
|
|
End If
|
|
Return m_cmdNew
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub NewProject()
|
|
SetBtlImage(DOWN_IMAGE)
|
|
CreateNewProd(False)
|
|
Return
|
|
End Sub
|
|
|
|
#End Region ' New
|
|
|
|
#Region "OpenCommand"
|
|
|
|
Public ReadOnly Property OpenCommand As ICommand
|
|
Get
|
|
If m_cmdOpen Is Nothing Then
|
|
m_cmdOpen = New Command(AddressOf Open)
|
|
End If
|
|
Return m_cmdOpen
|
|
End Get
|
|
End Property
|
|
|
|
Friend Sub Open()
|
|
' verifico se progetto modificato, e chiedo se salvare
|
|
If ProdFileVM.VerifyProjectModification(CurrProd) = MessageBoxResult.Cancel Then Return
|
|
OpenProject(Nothing)
|
|
End Sub
|
|
|
|
#End Region ' OpenCommand
|
|
|
|
#Region "OpenMruFileCommand"
|
|
|
|
Public ReadOnly Property OpenMruFileCommand As ICommand
|
|
Get
|
|
If m_cmdOpenMruFile Is Nothing Then
|
|
m_cmdOpenMruFile = New Command(AddressOf OpenMruFile)
|
|
End If
|
|
Return m_cmdOpenMruFile
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub OpenMruFile(ByVal param As Object)
|
|
' verifico se progetto modificato, e chiedo se salvare
|
|
If ProdFileVM.VerifyProjectModification(CurrProd) = MessageBoxResult.Cancel Then Return
|
|
' ricavo l'Id e il progetto associato per l'apertura di quest'ultimo
|
|
Dim PdId As Integer = 0
|
|
Dim arrStrPdId As String() = DirectCast(param, String).Split("|")
|
|
Integer.TryParse(arrStrPdId(0), PdId)
|
|
Dim PdFileM = DbControllers.m_ProdController.FindCoreByProdId(PdId)
|
|
Dim PdFileVM = New ProdFileVM(PdFileM)
|
|
OpenProject(PdFileVM)
|
|
End Sub
|
|
|
|
#End Region ' OpenMruFileCommand
|
|
|
|
#Region "SaveCommand"
|
|
|
|
Public ReadOnly Property SaveCommand As ICommand
|
|
Get
|
|
If m_cmdSave Is Nothing Then
|
|
m_cmdSave = New Command(AddressOf SaveCmd)
|
|
End If
|
|
Return m_cmdSave
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub SaveCmd()
|
|
Save(True)
|
|
End Sub
|
|
|
|
#End Region ' SaveCommand
|
|
|
|
#Region "ImportBTL"
|
|
|
|
Public ReadOnly Property ImportBTL_Command As ICommand
|
|
Get
|
|
If m_cmdImportBTL Is Nothing Then
|
|
m_cmdImportBTL = New Command(AddressOf ImportBTL)
|
|
End If
|
|
Return m_cmdImportBTL
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub ImportBTL(Optional sFile As String = "", Optional bWithDlg As Boolean = True)
|
|
' verifico se progetto modificato, e chiedo se salvare
|
|
If ProdFileVM.VerifyProjectModification(CurrProd) = MessageBoxResult.Cancel Then Return
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = False
|
|
Map.refProjectVM.SetSceneShowBuldingVisibility(False)
|
|
Map.refProjectVM.SetManagerTabVisibility(True)
|
|
If Not IsNothing(Map.refProjectVM.MachGroupPanelVM) Then Map.refProjectVM.SetFeatureListVisibility(True)
|
|
If Not CreateNewProd() Then
|
|
EgtOutLog("Errore! Creazione del progetto fallita!")
|
|
End If
|
|
Return
|
|
End Sub
|
|
|
|
#End Region ' ImportBTL
|
|
|
|
#Region "ExportProject"
|
|
|
|
Public ReadOnly Property ExportProject_Command As ICommand
|
|
Get
|
|
If m_cmdExportProject Is Nothing Then
|
|
m_cmdExportProject = New Command(AddressOf ExportProject)
|
|
End If
|
|
Return m_cmdExportProject
|
|
End Get
|
|
End Property
|
|
|
|
Public Function ExportProject(Optional sExportFileName As String = Nothing) As String
|
|
SetSaveImage(DOWN_IMAGE)
|
|
If ProdFileVM.VerifyProjectModification(CurrProd) = MessageBoxResult.Cancel Then Return Nothing
|
|
If IsNothing(CurrProd) Then Return Nothing
|
|
|
|
' apro finestra di salvataggio progetto
|
|
Dim ExportDlg As New Microsoft.Win32.SaveFileDialog() With {
|
|
.Title = EgtMsg(61838),
|
|
.DefaultExt = ".ngexp",
|
|
.Filter = "ProjectExport (*.ngexp)|*.ngexp",
|
|
.FileName = CurrProd.nProdId.ToString("0000") & " - " & CurrProd.sBTLFileName & " - ProjectExport"}
|
|
|
|
If IsNothing(sExportFileName) Then
|
|
If ExportDlg.ShowDialog() <> True Then
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
Return Nothing
|
|
End If
|
|
End If
|
|
|
|
LoadingWndHelper.OpenLoadingWnd(ActiveIds.EXPORTPROJECT, 2, EgtMsg(63010), EgtMsg(63016), 30) ' Project exporting ' Adding export info
|
|
' se assemblato me lo segno e lo smonto
|
|
Dim bShowBuilding As Boolean = False
|
|
If Map.refShowBeamPanelVM.bShowAll Then
|
|
' verifico se assemblato e lo annullo per salvataggio
|
|
bShowBuilding = Map.refShowBeamPanelVM.ShowBuilding_IsChecked
|
|
If bShowBuilding Then Map.refProjectVM.BTLStructureVM.ShowBuilding(False, False)
|
|
End If
|
|
|
|
' per ogni BTLInfo nel progetto riporto il relativo nome del BTL
|
|
Dim nBTLInfoProjId As Integer
|
|
Dim nBTLInfoLayerId As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, BTLINFO)
|
|
While nBTLInfoLayerId <> GDB_ID.NULL
|
|
' recupero il ProjId
|
|
EgtGetInfo(nBTLInfoLayerId, BTL_PRT_PROJ, nBTLInfoProjId)
|
|
If nBTLInfoProjId > 0 Then
|
|
' recupero il BTL file name di questo proj
|
|
Dim BTLFileNameProj As ProjFileM = DbControllers.m_ProjController.FindByProjIdConv(nBTLInfoProjId)
|
|
If Not IsNothing(BTLFileNameProj) Then
|
|
EgtSetInfo(nBTLInfoLayerId, BTLFILENAME, BTLFileNameProj.sBTLFileName)
|
|
End If
|
|
End If
|
|
nBTLInfoLayerId = EgtGetNextName(nBTLInfoLayerId, BTLINFO)
|
|
End While
|
|
' aggiungo layer per info di export
|
|
Dim nImpExpPartId As Integer = EgtCreateGroup(GDB_ID.ROOT)
|
|
EgtSetName(nImpExpPartId, EXP_PART)
|
|
' ci scrivo nome macchina e tipo progetto
|
|
EgtSetInfo(nImpExpPartId, EXP_MACHINE, CurrProd.sMachine)
|
|
EgtSetInfo(nImpExpPartId, BTL_GEN_PROJTYPE, CurrProd.nType)
|
|
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.EXPORTPROJECT, 2, EgtMsg(63017), 30, 100) ' Exporting...
|
|
' salvo info inserite
|
|
Map.refSceneHostVM.SaveProject()
|
|
' creo file zip
|
|
Dim sZipToCreate As String = If(IsNothing(sExportFileName), ExportDlg.FileName, Map.refMainWindowVM.MainWindowM.sTempDir & "\" & sExportFileName & ".ngexp")
|
|
If File.Exists(sZipToCreate) Then
|
|
File.Delete(sZipToCreate)
|
|
End If
|
|
Try
|
|
Using zipStream As New FileStream(sZipToCreate, FileMode.Create)
|
|
Using archive As New ZipArchive(zipStream, ZipArchiveMode.Create)
|
|
Dim sProjectDirPath As String = If(CurrProd.nProdId > 0, CurrProd.sProdDirPath, CurrProd.sProjDirPath)
|
|
|
|
For Each sFile As String In Directory.GetFiles(sProjectDirPath)
|
|
Dim entryName As String = Path.GetFileName(sFile)
|
|
Dim entry As ZipArchiveEntry = archive.CreateEntry(entryName, CompressionLevel.NoCompression)
|
|
|
|
Using entryStream As Stream = entry.Open()
|
|
Using fileStream As FileStream = File.OpenRead(sFile)
|
|
fileStream.CopyTo(entryStream)
|
|
End Using
|
|
End Using
|
|
Next
|
|
End Using
|
|
End Using
|
|
Catch ex1 As Exception
|
|
EgtOutLog("Exception in zip: " & ex1.ToString())
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62561))
|
|
End Try
|
|
' elimino layer di esportazione
|
|
EgtErase(nImpExpPartId)
|
|
' salvo eliminazione info inserite
|
|
Map.refSceneHostVM.SaveProject()
|
|
If bShowBuilding Then Map.refProjectVM.BTLStructureVM.ShowBuilding(True, False)
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.EXPORTPROJECT)
|
|
Return sZipToCreate
|
|
End Function
|
|
|
|
#End Region ' ExportProject
|
|
|
|
#Region "ImportProject"
|
|
|
|
Public ReadOnly Property ImportProject_Command As ICommand
|
|
Get
|
|
If m_cmdImportProject Is Nothing Then
|
|
m_cmdImportProject = New Command(AddressOf ImportProject)
|
|
End If
|
|
Return m_cmdImportProject
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub ImportProject()
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = False
|
|
Map.refProjectVM.SetSceneShowBuldingVisibility(False)
|
|
Map.refProjectVM.SetManagerTabVisibility(True)
|
|
SetOpenImage(DOWN_IMAGE)
|
|
Dim TempCurrProd As ProjectFileVM = CurrProd
|
|
If ProdFileVM.VerifyProjectModification(TempCurrProd) Then Return
|
|
|
|
Dim sDir As String = String.Empty
|
|
GetMainPrivateProfileString(S_GENERAL, K_LASTNGEXPDIR, "", sDir)
|
|
' apro finestra scelta file
|
|
Dim ImportDlg As New Microsoft.Win32.OpenFileDialog() With {
|
|
.Title = EgtMsg(61839),
|
|
.DefaultExt = ".ngexp",
|
|
.Filter = "ProjectExport (*.ngexp)|*.ngexp",
|
|
.InitialDirectory = If(Directory.Exists(sDir), sDir, ""),
|
|
.CheckFileExists = True,
|
|
.ValidateNames = True}
|
|
|
|
If ImportDlg.ShowDialog() <> True Then
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
Return
|
|
End If
|
|
|
|
' creo cartella temporanea di estrazione in Temp
|
|
Dim sProjectimportDir As String = Map.refMainWindowVM.MainWindowM.sTempDir & "\ProjectImport"
|
|
If Directory.Exists(sProjectimportDir) Then Directory.Delete(sProjectimportDir, True)
|
|
Directory.CreateDirectory(sProjectimportDir)
|
|
|
|
Try
|
|
If Directory.Exists(sProjectimportDir) Then Directory.Delete(sProjectimportDir, True)
|
|
ZipFile.ExtractToDirectory(ImportDlg.FileName, sProjectimportDir)
|
|
Catch ex1 As Exception
|
|
EgtOutLog("Exception in zip: " & ex1.ToString())
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62562), EgtMsg(15001))
|
|
Return
|
|
End Try
|
|
|
|
LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTPROJECT, 2, EgtMsg(63018), EgtMsg(63019), 30) ' Project importing ' Loading project
|
|
|
|
' carico progetto
|
|
Dim sProjFromPath() As String = Directory.GetFiles(sProjectimportDir, "*.nge")
|
|
Dim bOk = EgtOpenFile(sProjFromPath(0))
|
|
If Not bOk Then
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTPROJECT)
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62552), EgtMsg(15001))
|
|
Return
|
|
End If
|
|
|
|
' recupero e verifico se ho a disposizione la macchina con cui e' stato creato il progetto
|
|
Dim nImpExpPartId = EgtGetFirstNameInGroup(GDB_ID.ROOT, EXP_PART)
|
|
Dim sMachine As String = ""
|
|
EgtGetInfo(nImpExpPartId, EXP_MACHINE, sMachine)
|
|
Dim Machine As Machine = Map.refMachinePanelVM.MachineList.FirstOrDefault(Function(x) String.Equals(x.Name, sMachine, StringComparison.OrdinalIgnoreCase))
|
|
|
|
' se la macchina del progetto in apertura non è tra le macchine disponibili lo segnalo e apro un progetto vuoto
|
|
Dim nType As Integer = BWType.NULL
|
|
EgtGetInfo(nImpExpPartId, BTL_GEN_PROJTYPE, nType)
|
|
If IsNothing(Machine) OrElse nType = BWType.NULL Then
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTPROJECT)
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(61885), EgtMsg(10001), MessageBoxButton.OK, MessageBoxImage.Error) 'Error
|
|
Return
|
|
End If
|
|
|
|
' elimino part di esportazione
|
|
EgtErase(nImpExpPartId)
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTPROJECT, 2, EgtMsg(63020), 30, 100) ' Creating imported project
|
|
|
|
' leggo proj e prod presenti dai layer BTLInfo
|
|
Dim ImportProjIdList As New List(Of Integer)
|
|
Dim NewProjIdList As New List(Of Integer)
|
|
Dim BTLInfoIdList As New List(Of Integer)
|
|
Dim BTLFileNameList As New List(Of String)
|
|
Dim CurrImportProjId As Integer = 0
|
|
Dim nProdId As Integer = 0
|
|
Dim sProdDir As String = ""
|
|
Dim nBTLInfoLayerId As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, BTLINFO)
|
|
While nBTLInfoLayerId <> GDB_ID.NULL
|
|
' recupero il ProjId
|
|
EgtGetInfo(nBTLInfoLayerId, BTL_PRT_PROJ, CurrImportProjId)
|
|
If CurrImportProjId > 0 Then
|
|
ImportProjIdList.Add(CurrImportProjId)
|
|
BTLInfoIdList.Add(nBTLInfoLayerId)
|
|
' recupero nome file BTL Associato
|
|
Dim sBTLFileName As String = ""
|
|
EgtGetInfo(nBTLInfoLayerId, BTLFILENAME, sBTLFileName)
|
|
BTLFileNameList.Add(sBTLFileName)
|
|
End If
|
|
nBTLInfoLayerId = EgtGetNextName(nBTLInfoLayerId, BTLINFO)
|
|
End While
|
|
If Not ImportProjIdList.Count > 0 Then EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62563), EgtMsg(15001))
|
|
|
|
' carico i proj
|
|
For nProjIndex = 0 To ImportProjIdList.Count - 1
|
|
Dim nImportProjId As Integer = ImportProjIdList(nProjIndex)
|
|
' inizializzo nuovo proj
|
|
Dim nNewProjId As Integer = 0
|
|
Dim sNewProjDir As String = ""
|
|
InitNewProj(nNewProjId, sNewProjDir, nType, Machine.Name)
|
|
NewProjIdList.Add(nNewProjId)
|
|
' imposto ProjId di caricamento
|
|
ProjectManagerVM.nLoadingProjId = nImportProjId
|
|
' costruisco BTLStructure del proj
|
|
Map.refProjectVM.BTLStructureVM = New BTLStructureVM(BTLStructureM.CreateBTLStructure(nImportProjId))
|
|
' scrivo info proj su tutti i pezzi di questo progetto
|
|
For Each BTLPart In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
EgtSetInfo(BTLPart.nPartId, BTL_PRT_PROJ, nNewProjId)
|
|
Next
|
|
' cambio indicazione proj in gruppo di assemblaggio
|
|
Dim AsseBaseId As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, ASSEBASE)
|
|
While AsseBaseId <> GDB_ID.NULL
|
|
Dim nAsseBaseProj As Integer = 0
|
|
EgtGetInfo(AsseBaseId, BTL_PRT_PROJ, nAsseBaseProj)
|
|
If nAsseBaseProj = nImportProjId Then
|
|
EgtSetInfo(AsseBaseId, BTL_PRT_PROJ, NewProjIdList(nProjIndex))
|
|
Exit While
|
|
End If
|
|
AsseBaseId = EgtGetNextName(AsseBaseId, ASSEBASE)
|
|
End While
|
|
' riporto nuovo ProjId nel layer BTLInfo
|
|
EgtSetInfo(BTLInfoIdList(nProjIndex), BTL_PRT_PROJ, nNewProjId)
|
|
' resetto tutti gli stati di CALC
|
|
For Each BTLPart In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
BTLPart.ResetCalcTotalPart()
|
|
Next
|
|
' salvo modifiche fatte al progetto
|
|
bOk = bOk AndAlso Save()
|
|
If bOk Then
|
|
' aggiorno Db
|
|
Dim sBTLFileName As String = BTLFileNameList(nProjIndex)
|
|
Dim ExportDate As DateTime
|
|
DateTime.TryParse(Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPDATE & " " & Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPTIME, ExportDate)
|
|
DbControllers.m_ProjController.UpdateInfo(nNewProjId, sBTLFileName, sBTLFileName, Map.refProjectVM.BTLStructureVM.sLISTNAME, ExportDate, nType, Machine.Name)
|
|
Else
|
|
' elimino da Db
|
|
|
|
' CheckMe impostata come cancellazione FISICA dal DB...
|
|
DbControllers.m_ProjController.DeleteProj(nNewProjId, False)
|
|
End If
|
|
' aggiorno BTLParts su DB
|
|
DbControllers.m_ProjController.UpdateBtlParts(nNewProjId, Map.refProjectVM.BTLStructureVM.BTLStructureM.BTLPartMList)
|
|
' resetto stato new
|
|
DbControllers.m_ProjController.ResetNew(nNewProjId)
|
|
' resetto lock
|
|
DbControllers.m_ProjController.LockByProjId(nNewProjId, False, Map.refMainWindowVM.MainWindowM.GetKeyNumber())
|
|
DbControllers.m_ProjController.ResetController()
|
|
Next
|
|
|
|
' se tutte le operazioni precedenti sono andate a buon fine
|
|
If bOk Then
|
|
' sostituisco indicazione nuovi proj nei pezzi
|
|
Dim nDuploLayerId As Integer = EgtGetFirstNameInGroup(GDB_ID.ROOT, "DuploBase")
|
|
Dim nDuploId As Integer = EgtGetFirstInGroup(nDuploLayerId)
|
|
While nDuploId <> GDB_ID.NULL
|
|
' recupero vecchio proj
|
|
Dim nOldProjId As Integer
|
|
EgtGetInfo(nDuploId, BTL_PRT_PROJ, nOldProjId)
|
|
' lo cerco nella lista
|
|
Dim nOldProjIndex As Integer = ImportProjIdList.IndexOf(nOldProjId)
|
|
' lo sostituisco
|
|
EgtSetInfo(nDuploId, BTL_PRT_PROJ, NewProjIdList(nOldProjIndex))
|
|
nDuploId = EgtGetNext(nDuploId)
|
|
End While
|
|
|
|
' resetto CurrProd per evitare di leggere valori produzione dal Db di quel progetto
|
|
CurrProd = Nothing
|
|
|
|
' carico Machgroup che non verrebbero altrimenti importati
|
|
Map.refProjectVM.MachGroupPanelVM = New MyMachGroupPanelVM(MyMachGroupPanelM.CreateMyMachGroupPanel(Map.refMachinePanelVM.MachineList.ToList()))
|
|
|
|
' inizializzo nuovo progetto PROD
|
|
InitNewProd(NewProjIdList(0), nProdId, sProdDir)
|
|
|
|
' setto il PType del Prod
|
|
DbControllers.m_ProdController.UpdatePType(nProdId, nType)
|
|
|
|
' setto la Macchina associata al Prod
|
|
DbControllers.m_ProdController.UpdateMachine(nProdId, sMachine)
|
|
For Each MachGroup As MyMachGroupVM In Map.refProjectVM.MachGroupPanelVM.MachGroupVMList
|
|
' aggiorno ProdId sui MachGroup
|
|
EgtSetInfo(MachGroup.Id, MGR_RPT_PRODID, nProdId)
|
|
If Map.refMainWindowVM.MainWindowM.nUserLevel < 5 OrElse GetMainPrivateProfileInt(S_MACH, K_EXPORTBWE, 0) <> 1 Then
|
|
' resetto tutti gli stati di CALC
|
|
MachGroup.ResetCalcTotalMachGroup()
|
|
End If
|
|
Next
|
|
|
|
' imposto progetto corrente
|
|
If NewProjIdList.Count > 0 Then
|
|
SetCurrProj(NewProjIdList(0))
|
|
SetCurrProd(nProdId)
|
|
End If
|
|
|
|
If Map.refMainWindowVM.MainWindowM.nUserLevel >= 5 AndAlso GetMainPrivateProfileInt(S_MACH, K_EXPORTBWE, 0) = 1 Then
|
|
' lancio verifica perche' importato
|
|
Map.refCALCPanelVM.VerifyAll(ProjectType.PROJ, CalcIntegration.CmdTypes.CHECKNOSIM)
|
|
End If
|
|
|
|
' creo cartella per Proj
|
|
Dim sProjDirPath As String = sProdDir & "\Projs\" & NewProjIdList(0).ToString("0000")
|
|
Try
|
|
Directory.CreateDirectory(sProjDirPath)
|
|
Catch ex As Exception
|
|
EgtOutLog("Errore! Impossibile creare cartella del Proj!")
|
|
End Try
|
|
|
|
' salvo il progetto PROD
|
|
EgtSaveFile(sProjFromPath(0), NGE.CMPTEXT)
|
|
' copio file progetto
|
|
Dim sProjPath As String = String.Empty
|
|
Dim sProdPath As String = sProdDir & "\" & nProdId.ToString("0000") & ".nge"
|
|
If EgtGetCurrFilePath(sProjPath) AndAlso Not String.IsNullOrEmpty(sProjPath) Then
|
|
Try
|
|
File.Copy(sProjPath, sProdPath)
|
|
bOk = True
|
|
Catch ex As Exception
|
|
EgtOutLog("Impossibile copiare il file")
|
|
bOk = False
|
|
End Try
|
|
End If
|
|
If Map.refMainWindowVM.MainWindowM.nUserLevel >= 5 AndAlso GetMainPrivateProfileInt(S_MACH, K_EXPORTBWE, 0) = 1 Then
|
|
' copio tutti i bwe
|
|
For Each CurrFile In Directory.GetFiles(sProjectimportDir)
|
|
If Path.GetExtension(CurrFile) = ".bwe" OrElse Path.GetExtension(CurrFile) = ".html" Then
|
|
File.Copy(CurrFile, sProdDir & "\" & Path.GetFileName(CurrFile))
|
|
End If
|
|
Next
|
|
End If
|
|
If bOk Then
|
|
' aggiungo altri proj a prod
|
|
For Each nProjId In NewProjIdList
|
|
DbControllers.m_ProdController.AddProj(nProdId, nProjId, Map.refMainWindowVM.MainWindowM.GetKeyNumber())
|
|
Next
|
|
Else
|
|
' elimino da DB
|
|
DbControllers.m_ProdController.DeleteProd(nProdId, True)
|
|
End If
|
|
Dim MyMachGroupList As New List(Of MyMachGroupM)
|
|
If Not IsNothing(Map.refProjectVM.MachGroupPanelVM) Then
|
|
For Each MachGroup In Map.refProjectVM.MachGroupPanelVM.m_MyMachGroupPanelM.MachGroupMList
|
|
MyMachGroupList.Add(MachGroup)
|
|
Next
|
|
End If
|
|
' aggiorno pezzi su Db
|
|
DbControllers.m_ProdController.UpdateMachGroup(nProdId, MyMachGroupList)
|
|
' resetto lock
|
|
DbControllers.m_ProdController.LockByProdId(nProdId, False, Map.refMainWindowVM.MainWindowM.GetKeyNumber())
|
|
End If
|
|
DbControllers.m_ProdController.ResetController()
|
|
OpenProject(CurrProd)
|
|
WriteMainPrivateProfileString(S_GENERAL, K_LASTNGEXPDIR, Path.GetDirectoryName(ImportDlg.FileName))
|
|
LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTPROJECT)
|
|
End Sub
|
|
|
|
#End Region ' ImportProject
|
|
|
|
#Region "AddProj"
|
|
|
|
Public ReadOnly Property AddProj_Command As ICommand
|
|
Get
|
|
If m_cmdAddProj Is Nothing Then
|
|
m_cmdAddProj = New Command(AddressOf AddProj)
|
|
End If
|
|
Return m_cmdAddProj
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub AddProj()
|
|
SetBtlImage(DOWN_IMAGE)
|
|
If Not CreateNewProj(CurrProd, 0) Then
|
|
EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(62583))
|
|
End If
|
|
Return
|
|
End Sub
|
|
|
|
#End Region ' AddProj
|
|
|
|
#Region "AddBTL"
|
|
|
|
Public ReadOnly Property AddBTL_Command As ICommand
|
|
Get
|
|
If m_cmdAddBTL Is Nothing Then
|
|
m_cmdAddBTL = New Command(AddressOf AddBTL)
|
|
End If
|
|
Return m_cmdAddBTL
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub AddBTL()
|
|
'' verifico ci sia un progetto aperto
|
|
If IsNothing(CurrProd) Then Return
|
|
' apro finestra scelta file
|
|
Dim sDir As String = String.Empty
|
|
GetMainPrivateProfileString(S_GENERAL, K_LASTIMPDIR, "", sDir)
|
|
Dim sFile As String = ""
|
|
Dim BTLDlg As New Microsoft.Win32.OpenFileDialog() With {
|
|
.Title = EgtMsg(63038),
|
|
.DefaultExt = ".btl",
|
|
.Filter = "BTL (*.btl)|*.btl" &
|
|
"|BTLX (*.btlx)|*.btlx",
|
|
.InitialDirectory = If(Directory.Exists(sDir), sDir, ""),
|
|
.CheckFileExists = True,
|
|
.ValidateNames = True}
|
|
|
|
If BTLDlg.ShowDialog() Then
|
|
sFile = BTLDlg.FileName
|
|
Else
|
|
' Abilito pulsante assemblato
|
|
Map.refShowBeamPanelVM.ShowBuilding_IsEnabled = True
|
|
Return
|
|
End If
|
|
Dim nNewProjId As Integer = 0
|
|
Dim sProjDir As String = ""
|
|
' verifico se non e' tra i BTL gia' importati
|
|
Dim sBTLFileName As String = Path.GetFileNameWithoutExtension(sFile)
|
|
Dim nAlreadyImported As Integer = DbControllers.m_ProjController.AlreadyImported(sBTLFileName)
|
|
If nAlreadyImported > 0 Then
|
|
Select Case EgtBEAMWALL.Core.EgtMessageBoxV.Show(Application.Current.MainWindow, EgtMsg(61942), EgtMsg(15003), MessageBoxButton.YesNo, MessageBoxImage.Information) ' BTL file already imported and optimized. Do you want to import it again?
|
|
Case MessageBoxResult.Yes
|
|
' lo importo, quindi non devo fare nulla
|
|
Case MessageBoxResult.No
|
|
Return
|
|
End Select
|
|
End If
|
|
''LoadingWndHelper.OpenLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63008), EgtMsg(63009), 50) ' BTL file importing ' Reading BTL file
|
|
' inizializzo nuovo progetto
|
|
InitNewProj(nNewProjId, sProjDir, CurrProd.nType, CurrProd.sMachine)
|
|
' copio file BTL
|
|
Dim sBtlCopyPath As String = CurrProd.sProdDirPath & "\" & Path.GetFileName(sFile)
|
|
Dim bOk = False
|
|
Try
|
|
File.Copy(sFile, sBtlCopyPath, True)
|
|
bOk = True
|
|
Catch ex As Exception
|
|
EgtOutLog("Impossibile copiare il file")
|
|
bOk = False
|
|
End Try
|
|
If bOk Then
|
|
bOk = Map.refSceneHostVM.MainController.InsertProject(sBtlCopyPath, False)
|
|
End If
|
|
Dim sProjFileName As String = sProjDir & "\" & nNewProjId.ToString("0000") & ".nge"
|
|
If bOk Then
|
|
' salvo il progetto
|
|
bOk = EgtSaveFile(sProjFileName, NGE.CMPTEXT)
|
|
SectionXMaterial.SetType(nType)
|
|
Core.ViewPanelVM.UpdateBWType(nType)
|
|
' imposto flag secondo tipo di progetto (travi o pareti)
|
|
Dim sBTLFlag As String = If(nType = Core.ConstBeam.BWType.BEAM, K_BTLFLAG, K_WALLBTLFLAG)
|
|
Dim nFlag As Integer = GetMainPrivateProfileInt(S_IMPORT, sBTLFlag, EIB_FL.TS3_POS + EIB_FL.SORT + EIB_FL.USEUATTR)
|
|
EgtBeamSetFlag(nFlag)
|
|
Else
|
|
EgtOutLog("Errore nell'importazione BTL")
|
|
End If
|
|
If bOk Then
|
|
' aggiorno Db
|
|
Dim ExportDate As DateTime
|
|
DateTime.TryParse(Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPDATE & " " &
|
|
Map.refProjectVM.BTLStructureVM.BTLStructureM.m_sEXPTIME, ExportDate)
|
|
DbControllers.m_ProjController.UpdateInfo(nNewProjId, sBTLFileName, sBTLFileName, Map.refProjectVM.BTLStructureVM.sLISTNAME, ExportDate, nType, ProjectManagerVM.CurrProd.sMachine)
|
|
SetCurrProj(nNewProjId)
|
|
' se progetto pareti e vista ruotata
|
|
If nType = BWType.WALL AndAlso (CurrentMachine.ViewDir = VT.ISO_NW OrElse CurrentMachine.ViewDir = VT.ISO_NE) Then
|
|
' ruoto le pareti di 180 per raddrizzarle rispetto alla vista
|
|
For Each Wall In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
Wall.Rotation(True, Map.refProjectVM.BTLStructureVM.nPROJTYPE, True, 180, False)
|
|
Next
|
|
End If
|
|
' calcolo volumi pezzi
|
|
For Each Part In Map.refProjectVM.BTLStructureVM.BTLPartVMList
|
|
Part.CalcBTLPartVolume()
|
|
Next
|
|
Map.refProjectVM.SetOptimizePanel_Visibility(Map.refProjectVM.BTLStructureVM.nPROJTYPE = BWType.WALL AndAlso Map.refMainWindowVM.MainWindowM.GetKeyOption(KEY_OPT.NESTING_AUTO))
|
|
LoadingWndHelper.UpdateLoadingWnd(ActiveIds.IMPORTBTL, 3, EgtMsg(63006), 70, 100) ' Loading graphics
|
|
' mostro tutti i pezzi
|
|
Map.refShowBeamPanelVM.ShowAll(True)
|
|
Else
|
|
' elimino da Db
|
|
' CheckMe impostata come cancellazione FISICA dal DB...
|
|
DbControllers.m_ProjController.DeleteProj(nNewProjId, False)
|
|
End If
|
|
If bOk Then
|
|
' salvo il progetto
|
|
bOk = EgtSaveFile(sProjFileName, NGE.CMPTEXT)
|
|
End If
|
|
' carico filtri di ricerca
|
|
Map.refProjectVM.BTLStructureVM.LoadFilters()
|
|
' gestisco log di importazione
|
|
ManageImportLog(nNewProjId, sProjDir)
|
|
'LoadingWndHelper.CloseLoadingWnd(ActiveIds.IMPORTBTL)
|
|
|
|
' lo salvo
|
|
bOk = bOk AndAlso Save(False)
|
|
If bOk Then
|
|
' riporto aggiunta proj a prod su Db
|
|
DbControllers.m_ProdController.AddProj(CurrProd.nProdId, nNewProjId)
|
|
End If
|
|
' Ricavo il tipo di Warehouse settato nell'INI
|
|
Dim nDefault As Integer = 2
|
|
If GetMainPrivateProfileInt(S_WAREHOUSE, EgtBEAMWALL.Core.ConstIni.K_TYPE, nDefault) = WarehouseType.MEDIUM Then
|
|
' Se di tipo Medium confronto le Sezioni del BTL importato con quelle in Warehouse
|
|
WarehouseWndVM.UpdateSectionXMaterial()
|
|
End If
|
|
' aggiorno CurrProd
|
|
Dim PdFileM = DbControllers.m_ProdController.FindCoreByProdId(CurrProd.nProdId)
|
|
CurrProd.ProdFileM.SetProjIdList(PdFileM.nProjIdList)
|
|
' ricarico BTLPartList
|
|
OpenProject(CurrProd)
|
|
End Sub
|
|
|
|
#End Region ' AddBTL
|
|
|
|
#Region "ShowPopUpStartBtnCommand"
|
|
|
|
Public ReadOnly Property ShowPopUpStartBtnCommand As ICommand
|
|
Get
|
|
If m_cmdShowPopUpStartBtnCmd Is Nothing Then
|
|
m_cmdShowPopUpStartBtnCmd = New Command(AddressOf ShowPopUpStartBtn)
|
|
End If
|
|
Return m_cmdShowPopUpStartBtnCmd
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub ShowPopUpStartBtn(ByVal param As Object)
|
|
If m_IsStartBtnOpen Then
|
|
SetBtlImage(DOWN_IMAGE)
|
|
SetOpenImage(UP_IMAGE)
|
|
SetSaveImage(UP_IMAGE)
|
|
SetIsStartBtnOpen(False)
|
|
Else
|
|
SetBtlImage(UP_IMAGE)
|
|
SetIsStartBtnOpen(True)
|
|
End If
|
|
End Sub
|
|
|
|
#End Region ' ShowPopUpStartBtnCommand
|
|
|
|
#Region "ShowPopUpSaveBtnCommand"
|
|
|
|
Public ReadOnly Property ShowPopUpSaveBtnCommand As ICommand
|
|
Get
|
|
If m_cmdShowPopUpSaveBtnCmd Is Nothing Then
|
|
m_cmdShowPopUpSaveBtnCmd = New Command(AddressOf ShowPopUpSaveBtn)
|
|
End If
|
|
Return m_cmdShowPopUpSaveBtnCmd
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub ShowPopUpSaveBtn(ByVal param As Object)
|
|
If m_IsSaveBtnOpen Then
|
|
SetOpenImage(DOWN_IMAGE)
|
|
SetSaveImage(UP_IMAGE)
|
|
SetBtlImage(UP_IMAGE)
|
|
SetIsSaveBtnOpen(False)
|
|
Else
|
|
SetOpenImage(UP_IMAGE)
|
|
SetIsSaveBtnOpen(True)
|
|
End If
|
|
End Sub
|
|
|
|
#End Region ' ShowPopUpSaveBtnCommand
|
|
|
|
#Region "ShowPopUpBtlBtnCommand"
|
|
|
|
Public ReadOnly Property ShowPopUpBtlBtnCommand As ICommand
|
|
Get
|
|
If m_cmdShowPopUpBtlBtnCmd Is Nothing Then
|
|
m_cmdShowPopUpBtlBtnCmd = New Command(AddressOf ShowPopUpBtlBtn)
|
|
End If
|
|
Return m_cmdShowPopUpBtlBtnCmd
|
|
End Get
|
|
End Property
|
|
|
|
Public Sub ShowPopUpBtlBtn(ByVal param As Object)
|
|
If m_IsBtlBtnOpen Then
|
|
SetSaveImage(DOWN_IMAGE)
|
|
SetOpenImage(UP_IMAGE)
|
|
SetBtlImage(UP_IMAGE)
|
|
SetIsBtlBtnOpen(False)
|
|
Else
|
|
SetSaveImage(UP_IMAGE)
|
|
SetIsBtlBtnOpen(True)
|
|
End If
|
|
End Sub
|
|
|
|
#End Region ' ShowPopUpBtlBtnCommand
|
|
|
|
#End Region ' Commands
|
|
|
|
End Class |