=
430 lines
11 KiB
TypeScript
430 lines
11 KiB
TypeScript
import Vue from "vue";
|
|
import Component from "vue-class-component";
|
|
|
|
import { ModalHelper,Modal } from "@/components/modals";
|
|
import { Factory, messageService, awaiter } from "../../_base";
|
|
// import { MaintenanceService } from "../services/maintenanceService";
|
|
// import { store } from "@/store";
|
|
// import { maintenanceActions } from "../store/maintenance.store";
|
|
import moment from "moment";
|
|
import cardFolderPath from "./cards/card-folder-path.vue";
|
|
import cardElementQueue from "@/app_modules/production/components/card-element-queue.vue";
|
|
import * as iziToast from "izitoast";
|
|
import { fileService } from "../../services/fileService";
|
|
import ZoomImage from './zoom-image.vue'
|
|
|
|
declare var cmsClient: any;
|
|
|
|
interface PathInfo {
|
|
Name: string;
|
|
AbsolutePath: string;
|
|
Path: string;
|
|
IsDirectory: boolean;
|
|
IsMain: boolean;
|
|
FileExist: boolean;
|
|
}
|
|
|
|
interface FileInfo {
|
|
Name: string;
|
|
AbsolutePath: string;
|
|
CreationDate: string;
|
|
LastModDate: string;
|
|
Content: Array<any>;
|
|
PreviewBase64: any;
|
|
CanEdit: boolean;
|
|
IsJob: boolean;
|
|
}
|
|
|
|
@Component({
|
|
components: {
|
|
modal: Modal,
|
|
cardFolderPath,
|
|
cardElementQueue,
|
|
ZoomImage
|
|
}
|
|
})
|
|
|
|
export default class ModalLoadProgram extends Vue {
|
|
|
|
driveList: Array<PathInfo> = [];
|
|
currentPath: string = "";
|
|
currentDrive: string = null;
|
|
lastClickPath: string = "";
|
|
|
|
breadcrumbs: Array<any> = [];
|
|
|
|
firstColumnData: Array<PathInfo> = [];
|
|
secondColumnData: Array<PathInfo> = [];
|
|
|
|
isLocalNavigation: boolean = true;
|
|
selectedFile: FileInfo = null;
|
|
selectedFileMetadata = null;
|
|
|
|
currentFilterFirst: string = "";
|
|
currentFilterSecond: string = "";
|
|
|
|
navigationDepth: number = 0;
|
|
selectedNumberImage: number = 0;
|
|
showZoomedImage: boolean = false;
|
|
mustCLeanPProgram: boolean = false;
|
|
fileIsChanged: boolean = false;
|
|
|
|
uploadAllFileInFolder: boolean = false;
|
|
onLabel: string = "On";
|
|
offLabel: string = "Off";
|
|
recentPath: string = ""
|
|
thereAreFileEliminated: boolean = false
|
|
askConfirmLayer: boolean = false
|
|
loadClicked: boolean = false
|
|
recentDriveSelected: boolean = false
|
|
|
|
get machineInfo() {
|
|
return this.$store.state.machineInfo;
|
|
}
|
|
|
|
get canLoadProgram() {
|
|
return this.$store.state.process.canLoadProgram;
|
|
}
|
|
|
|
async mounted() {
|
|
if (typeof cmsClient != "undefined") {
|
|
this.driveList = JSON.parse(cmsClient.getOSdriveList());
|
|
this.recentPath = cmsClient.RECENT_FOLDER_KEY
|
|
}
|
|
|
|
this.loadClicked = false
|
|
}
|
|
|
|
async navigateTo(path: string, absolutePath: string, local: boolean, todepth: number, fromdepth: number) {
|
|
this.currentPath = absolutePath;
|
|
this.lastClickPath = absolutePath;
|
|
this.checkChangeNavigationType(local);
|
|
this.selectedFile = null;
|
|
this.selectedFileMetadata = null;
|
|
var files = await this.getFilesForPath(absolutePath, path, local);
|
|
// controlla se impostare il currentDrive
|
|
if (fromdepth == 0) this.currentDrive = absolutePath;
|
|
|
|
// controlla come organizzare le colonne.
|
|
if (this.navigationDepth == 2 && todepth == 2 && fromdepth == 2) {
|
|
this.fillArray(this.firstColumnData, this.secondColumnData);
|
|
}
|
|
|
|
this.navigationDepth = todepth;
|
|
// Check destination depth
|
|
if (todepth == 1) {
|
|
this.fillArray(this.firstColumnData, files);
|
|
this.secondColumnData.splice(0, this.secondColumnData.length);
|
|
this.currentFilterFirst = "";
|
|
}
|
|
|
|
if (todepth == 2) {
|
|
this.fillArray(this.secondColumnData, files);
|
|
this.currentFilterSecond = "";
|
|
}
|
|
|
|
// Recent column
|
|
if(path == this.recentPath) {
|
|
var main = null;
|
|
// Parse files
|
|
files.forEach((element) => {
|
|
// Check if there is a deleted file
|
|
if(element.FileExist == false)
|
|
this.thereAreFileEliminated = true
|
|
// Return only the main program
|
|
if(element.IsMain == true)
|
|
main = element
|
|
})
|
|
|
|
// If there is a main program
|
|
if(main != null) {
|
|
this.fileInfo(main.AbsolutePath, false, 1)
|
|
this.uploadAllFileInFolder = true;
|
|
this.recentDriveSelected = true;
|
|
}
|
|
}
|
|
else {
|
|
this.uploadAllFileInFolder = false;
|
|
this.thereAreFileEliminated = false;
|
|
this.recentDriveSelected = false;
|
|
}
|
|
|
|
this.calcBreadCrumb(absolutePath);
|
|
this.cleanFileWatcher();
|
|
}
|
|
|
|
fillArray(destinationArray: Array<any>, sourceArray: Array<any>) {
|
|
destinationArray.splice(0, destinationArray.length);
|
|
for (const key in sourceArray) {
|
|
if (sourceArray.hasOwnProperty(key)) {
|
|
const element = sourceArray[key];
|
|
destinationArray.push(element);
|
|
}
|
|
}
|
|
}
|
|
|
|
checkChangeNavigationType(local: boolean) {
|
|
if (this.isLocalNavigation != local) {
|
|
this.navigationDepth = 0;
|
|
this.firstColumnData.splice(0, this.firstColumnData.length);
|
|
this.secondColumnData.splice(0, this.secondColumnData.length);
|
|
}
|
|
}
|
|
|
|
async getFilesForPath(absolutePath: string, path: string, local: boolean): Promise<Array<any>> {
|
|
this.isLocalNavigation = local;
|
|
var result = null;
|
|
|
|
if (local)
|
|
result = JSON.parse(cmsClient.getFileList(absolutePath));
|
|
else
|
|
result = await awaiter(fileService.getFiles(path));
|
|
|
|
return this.toUpperCaseModel(result).sort(this.compareDirectoriesFirst);
|
|
}
|
|
|
|
private compareDirectoriesFirst(x, y) {
|
|
return (x.IsDirectory === y.IsDirectory) ? 0 : x.IsDirectory ? -1 : 1;
|
|
}
|
|
|
|
toUpperCaseModel(data: Array<any>): Array<PathInfo> {
|
|
return data.map(i => {
|
|
return {
|
|
Name: i.name || i.Name,
|
|
AbsolutePath: i.absolutePath || i.AbsolutePath,
|
|
Path: i.path || i.Path,
|
|
IsDirectory: (i.isDirectory != null && i.isDirectory) || (i.IsDirectory != null && i.IsDirectory),
|
|
IsJob: i.isJob,
|
|
IsMain: i.IsMain,
|
|
FileExist: i.FileExist
|
|
};
|
|
});
|
|
}
|
|
|
|
calcBreadCrumb(path: string) {
|
|
this.breadcrumbs.splice(0, this.breadcrumbs.length);
|
|
if (path.startsWith("\\\\")) {
|
|
this.breadcrumbs.push({
|
|
name: "CN",
|
|
path: "\\\\"
|
|
});
|
|
}
|
|
|
|
if (path) {
|
|
var fragments = path.split("\\");
|
|
var __p = "";
|
|
fragments.forEach(element => {
|
|
__p = __p + element + "\\";
|
|
this.breadcrumbs.push({
|
|
name: element,
|
|
path: __p
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
isInPath(path,isDirectory) {
|
|
if (this.currentPath) {
|
|
if(!this.uploadAllFileInFolder || !this.isLocalNavigation)
|
|
return path == this.currentPath;
|
|
else
|
|
return (path.startsWith(this.currentPath) && !isDirectory) || (path == this.currentPath && isDirectory);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
toUpperCaseFileModel(data: any): FileInfo {
|
|
return {
|
|
AbsolutePath: data.absolutePath || data.AbsolutePath,
|
|
Path: data.path || data.Path,
|
|
Content: data.content || data.Content,
|
|
CreationDate: data.creationDate || data.CreationDate,
|
|
LastModDate: data.lastModDate || data.LastModDate,
|
|
Name: data.name || data.Name,
|
|
PreviewBase64: data.previewBase64 || data.PreviewBase64,
|
|
IsJob: data.isJob || data.IsJob,
|
|
CanEdit: data.canEdit || data.CanEdit
|
|
} as FileInfo;
|
|
}
|
|
|
|
async fileInfo(str, isJob, fromdepth: number) {
|
|
this.lastClickPath = str;
|
|
if (fromdepth == 1)
|
|
this.secondColumnData.splice(0, this.secondColumnData.length);
|
|
|
|
if (this.isLocalNavigation && typeof cmsClient != "undefined"){
|
|
// Select file
|
|
this.selectedFile = this.toUpperCaseFileModel(
|
|
JSON.parse(cmsClient.getProgramInfo(str))
|
|
);
|
|
|
|
// Check if the file it's a job and get data
|
|
this.selectedFile.IsJob = isJob;
|
|
if(isJob){
|
|
var resp = JSON.parse(cmsClient.readJobMetadata(str));
|
|
if(resp.error)
|
|
{
|
|
this.selectedFile = null;
|
|
(iziToast as any).error({
|
|
title: "error",
|
|
message: resp.error,
|
|
theme: "dark",
|
|
timeout: 10000,
|
|
class: "t-error",
|
|
transitionOut: "fadeOut",
|
|
})
|
|
return
|
|
}
|
|
this.selectedFileMetadata = resp.metadata;
|
|
this.selectedNumberImage = 0;
|
|
}
|
|
}
|
|
if (!this.isLocalNavigation)
|
|
this.selectedFile = this.toUpperCaseFileModel(
|
|
await awaiter(fileService.getFileInfo(str)));
|
|
|
|
this.currentPath = this.selectedFile.AbsolutePath.substring(0, this.selectedFile.AbsolutePath.lastIndexOf("\\"));
|
|
this.cleanFileWatcher();
|
|
}
|
|
|
|
beforeMount() {
|
|
messageService.subscribeToChannel("esc_pressed", args => {
|
|
this.close();
|
|
});
|
|
if(!this.machineInfo.isOsai) {
|
|
awaiter (fileService.isTempFolderOK().then(response => {
|
|
this.mustCLeanPProgram = !response;
|
|
}));
|
|
}
|
|
}
|
|
|
|
beforeDestroy() {
|
|
messageService.deleteChannel("esc_pressed");
|
|
}
|
|
|
|
close() {
|
|
this.cleanFileWatcher()
|
|
messageService.deleteChannel("esc_pressed");
|
|
ModalHelper.HideModal();
|
|
}
|
|
|
|
reload() {
|
|
this.driveList = JSON.parse(cmsClient.getOSdriveList());
|
|
}
|
|
|
|
getDate(date) {
|
|
return moment(date).format("L");
|
|
}
|
|
|
|
async load(item: FileInfo) {
|
|
if(!this.thereAreFileEliminated || this.askConfirmLayer) {
|
|
this.loadClicked = true
|
|
|
|
if (item.IsJob)
|
|
this.loadJob(item.AbsolutePath);
|
|
else
|
|
this.loadProgram(item.AbsolutePath);
|
|
|
|
this.askConfirmLayer = false
|
|
}
|
|
else {
|
|
this.askConfirmLayer = true
|
|
}
|
|
this.loadClicked = false
|
|
}
|
|
|
|
async loadProgram (path: string) {
|
|
if (this.isLocalNavigation && typeof cmsClient != "undefined") {
|
|
var resp = cmsClient.uploadAndActivateProgram(path, this.uploadAllFileInFolder, this.recentDriveSelected);
|
|
if (resp != "")
|
|
(iziToast as any).error({
|
|
title: resp.split(";")[0],
|
|
message: resp.split(";")[1],
|
|
theme: "dark",
|
|
timeout: 10000,
|
|
class: "t-error",
|
|
transitionOut: "fadeOut",
|
|
})
|
|
else
|
|
this.close();
|
|
}
|
|
|
|
if (!this.isLocalNavigation) {
|
|
await awaiter(fileService.activateProgram(path));
|
|
this.close();
|
|
}
|
|
}
|
|
|
|
selectNumberImage(value) {
|
|
this.selectedNumberImage = value;
|
|
}
|
|
|
|
async loadJob(path: string) {
|
|
var jobMetadata = cmsClient.readJobMetadata(path);
|
|
}
|
|
|
|
ToggleShowZoomedImage() {
|
|
this.showZoomedImage = !this.showZoomedImage;
|
|
}
|
|
|
|
toggleUploadAllFileInFolder() {
|
|
this.uploadAllFileInFolder = !this.uploadAllFileInFolder;
|
|
}
|
|
|
|
async cleanTempfolder() {
|
|
await awaiter(fileService.cleanTempFolder());
|
|
await awaiter (fileService.isTempFolderOK().then(response => {
|
|
this.mustCLeanPProgram = !response;
|
|
}));
|
|
}
|
|
|
|
async backupTempfolder() {
|
|
await awaiter(fileService.backupTempFolder());
|
|
await awaiter (fileService.isTempFolderOK().then(response => {
|
|
this.mustCLeanPProgram = !response;
|
|
}));
|
|
}
|
|
|
|
editprogram(){
|
|
var res = cmsClient.editProgram(this.selectedFile.AbsolutePath, this.fileChanged);
|
|
if (res) {
|
|
var obj = JSON.parse(res);
|
|
if (obj.error){
|
|
(iziToast as any).error({
|
|
title: "error",
|
|
message: obj.error,
|
|
theme: "dark",
|
|
timeout: 10000,
|
|
class: "t-error",
|
|
transitionOut: "fadeOut",
|
|
})
|
|
}
|
|
}
|
|
else {
|
|
this.fileIsChanged = false;
|
|
}
|
|
}
|
|
|
|
fileChanged() {
|
|
this.fileIsChanged = true;
|
|
}
|
|
|
|
reloadProgram() {
|
|
this.fileInfo(this.selectedFile.AbsolutePath, this.selectedFile.IsJob, this.navigationDepth)
|
|
this.fileIsChanged = false;
|
|
}
|
|
|
|
cleanFileWatcher() {
|
|
this.fileIsChanged = false;
|
|
cmsClient.cleanFileWatcher()
|
|
}
|
|
|
|
askConfirmOkClick(){
|
|
this.load(this.selectedFile)
|
|
}
|
|
|
|
askConfirmCancelClick(){
|
|
this.askConfirmLayer = false;
|
|
}
|
|
}
|