Skriv til fil i "AppData" i Electron. Hvor legge til import {app} fra "elektron" ;?

stemmer
0

Jeg gjør mitt første Electron søknad. Jeg prøver å lagre en tekstfil til AppData-mappen (f.eks C: \ Users \ brukernavn \ AppData \ Roaming). Jeg vet at jeg må legge til import {app} fra elektron; noen der, men jeg er usikker på hvor du skal plassere den.

I mine index.js javascript jeg skriver databasen innstillingene som brukeren sender i sitt skjema til en tekstfil. Det er der jeg trenger å ha AppData katalogen adresse.

// Write data to text file
var filepath = app.getPath(appData) 
var filename = database_quick_image_forensics.txt
var inp_data = inp_host + | + inp_username + | + inp_password + | + inp_database_name + | + inp_table_prefix;
write_to_file(filepath, filename, inp_data);

Min hele koden nedenfor:

./setup/index.html

<!DOCTYPE html>
<html>
<head>
    <meta charset=UTF-8>
    <title>Setup</title>
    <!-- https://electronjs.org/docs/tutorial/security#csp-meta-tag -->

        <!-- CSS -->
            <link rel=stylesheet type=text/css href=../_webdesign/dark/dark.css />
        <!-- // CSS -->


    <!-- jQuery -->
    <script>window.$ = window.jQuery = require('../javascripts/jquery/jquery-3.4.1.js');</script>
    <script src=../javascripts/jquery/jquery-3.4.1.js charset=utf-8></script>
    <!-- //jQuery -->

    <!-- jQuery -->
    <script src=./index.js charset=utf-8></script>
    <!-- //jQuery -->
</head>
<body>
<div id=main_single_column>
  <h1>Setup</h1>

<!-- Feedback -->
    <div id=feedback_div class=success>
        <p id=feedback_p>Success</p>
    </div>
<!-- //Feedback -->

<!-- Database connection form -->

      <p>Host:<br />
      <input type=text name=inp_host id=inp_host value=localhost />
      </p>

      <p>Port:<br />
      <input type=text name=inpport id=inp_port value= />
      </p>

      <p>Username:<br />
      <input type=text name=inp_username id=inp_username value=root />
      </p>

      <p>Password:<br />
      <input type=text name=inp_password id=inp_password />
      </p>

      <p>Database name:<br />
      <input type=text name=inp_database_name id=inp_database_name value=quick />
      </p>

      <p>Table prefix:<br />
      <input type=text name=inp_table_prefix id=inp_table_prefix value=cf_ />
      </p>

      <p>
      <button id=form_connect_to_database_submit>Connect to database</button>
      </p>

<!-- //Database connection form -->
</div>



</body>
</html>

./setup/index.js

const fs = require('fs');

// Action = On submit
$(document).ready(function(){

    $(#form_connect_to_database_submit).click( function() {
        // Feedback
        $('#feedback_div').show();
        $('#feedback_div').removeClass(success);
        $('#feedback_div').addClass(info);
        $('#feedback_p').text(Connecting!)

        // get all the inputs
        var inp_host = $(#inp_host). val();
        var inp_username = $(#inp_username). val();
        var inp_password = $(#inp_password). val();
        var inp_database_name = $(#inp_database_name). val();
        var inp_table_prefix = $(#inp_table_prefix). val();

        // Test connection
        var connection_result = connect_to_database(inp_host, inp_username, inp_password, inp_database_name, inp_table_prefix);
        if(connection_result != connection_ok){
            // Connection Failed
            $('#feedback_div').removeClass(info);
            $('#feedback_div').addClass(error);
            $('#feedback_p').text(connection_result)
        }
        else{
            // Connection OK
            $('#feedback_div').removeClass(info);
            $('#feedback_div').addClass(success);
            $('#feedback_p').text(Connected)

            // Write data to text file
            var filepath = app.getPath(appData) 
            var filename = database_quick_image_forensics.txt
            var inp_data = inp_host + | + inp_username + | + inp_password + | + inp_database_name + | + inp_table_prefix;
            $('#feedback_p').text(Connected  + filepath)
            write_to_file(filepath, filename, inp_data);

            // Feedback
            $('#feedback_div').removeClass(info);
            $('#feedback_div').addClass(success);
            $('#feedback_p').text(Connected to)
        }




    });
    $('#inp_host').focus();
});


// Function connect to database
function connect_to_database(inp_host, inp_username, inp_password, inp_database_name, inp_table_prefix){
    var mysql = require('mysql');

    // Add the credentials to access your database
    var connection = mysql.createConnection({
        host     : inp_host,
        user     : inp_username,
        password : null, // or the original password : 'apaswword'
        database : inp_database_name
    });

    // connect to mysql
    connection.connect(function(err) {
        // in case of error
        if(err){
            console.log(err.code);
            console.log(err.fatal);
            return err.code;
        }
    });


    // Perform a query
    $query = 'SELECT * FROM `cf_admin_liquidbase` LIMIT 10';
    connection.query($query, function(err, rows, fields) {
        if(err){
            console.log(An error ocurred performing the query.);
            console.log(err);
            return;
        }
        console.log(Query succesfully executed, rows);
    });

    return connection_ok;
} // connect_to_database




// Function write setup
function write_to_file(filepath, filename, inp_data){


    var fullpath = filepath + \\ + filename;
    fs.writeFile(fullpath, inp_data, (err) => {
        // throws an error, you could also catch it here
        if (err) throw err;
        // success case, the file was saved
        console.log('Lyric saved!');
    });
} // write_to_file

./main.js

const { app, BrowserWindow } = require('electron')


// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let win


function createWindow () {
  // Create the browser window.
  win = new BrowserWindow({
          width: 800,
          height: 600,
          webPreferences: {
          nodeIntegration: true
          }
  })

  // and load the index.html of the app.
  win.loadFile('index.html')

  // Open the DevTools.
  // win.webContents.openDevTools()

  // Emitted when the window is closed.
  win.on('closed', () => {
          // Dereference the window object, usually you would store windows
          // in an array if your app supports multi windows, this is the time
          // when you should delete the corresponding element.
          win = null
  })
}

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', createWindow)

// Quit when all windows are closed.
app.on('window-all-closed', () => {
  // On macOS it is common for applications and their menu bar
  // to stay active until the user quits explicitly with Cmd + Q
  if (process.platform !== 'darwin') {
          app.quit()
  }
})

app.on('activate', () => {
  // On macOS it's common to re-create a window in the app when the
  // dock icon is clicked and there are no other windows open.
  if (win === null) {
          createWindow()
  }
})

// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.
Publisert på 13/01/2020 klokken 23:58
kilden bruker
På andre språk...                            


2 svar

stemmer
2

Jeg vet at jeg må legge til import {app} fra "elektron"; noen der, men jeg er usikker på hvor du skal plassere den.

Den app modulen er alltid (i min erfaring) importert i mainprosessen slik at du kan styre programmer livssyklus. Men hvis du ønsker å bruke noe av appmodulen funksjonalitet i rendererprosessen, kan du importere det der gjennom remotemodulen (som vist på aksepterte svaret på dette spørsmålet: Hvordan bruke elektronets app.getPath () for å lagre data )

const remote = require('electron').remote;
const app = remote.app;
console.log(app.getPath('userData'));

Den mainog rendererprosesser er sentrale begreper i Electronså jeg foreslår at du leser opp på disse. Kjernen er at du har en mainprosess - det har ingen visuell representasjon og det er involvert i livssyklusen til programmet ditt, skape og ødelegge rendererprosesser (som BrowserWindows ), kommunikasjon mellom renderer prosesser, etc. - og du kan ha så mange rendererprosesser som du trenger.

Så hvis du ønsker å lese og skrive filer kan du gjøre det i rendererprosessen som vist ovenfor - eller du kan gjøre det i mainprosessen. I sistnevnte tilfelle, hvis en rendererprosess ønsker å lagre en fil, kan det budskapet den mainprosessen gjennom IPC , sende dataene som skal lagres.

Hvilken vei du gjør det er en arkitektonisk valg.

Svarte 14/01/2020 kl. 02:08
kilden bruker

stemmer
1

For å få app banen på din hovedprosessen . Deretter kan du bruke denne koden på din main.js

switch(process.platform) {
    case 'darwin': {
      return path.join(process.env.HOME, 'Library', 'Application Support', ...);
    }
    case 'win32': {
      return path.join(process.env.APPDATA, ...);
    }
    case 'linux': {
      return path.join(process.env.HOME, ...);
    }
}

Og kommer til å få banen fra renderer deretter bruke denne koden på din renderer

const remote = require('electron').remote;
const app = remote.app;
console.log(app.getPath('userData'));

Men å bruke kreve av din renderer, må du sørge for nodeintegration er sant.

Hvis jeg var deg, jeg hadde tenkt å få app banen på hovedprosessen og lagre filen på hovedprosessen i tillegg. Derfor importerer mange avhengigheter på gjengivelsesprosessen er ikke et godt valg. Den gjengivelsesprosessen tar hovedsakelig vare på å vise din app i Chromium nettleser.

Så for å gjøre denne operasjonen på hovedprosessen . Bruk denne

på dine main.js

  const { ipcMain } = require('electron')
  const appPath = () => {
    switch(process.platform) {
      case 'darwin': {
        return path.join(process.env.HOME, 'Library', 'Application Support');
      }
      case 'win32': {
        return process.env.APPDATA;
      }
      case 'linux': {
        return process.env.HOME;
      }
    }
  }

  const writeToFile = (fileName, inData) => {
      const fullPath = path.join(appPath(), "\\", fileName);
      fs.writeFile(fullPath, inData, (err) => {
        // throws an error, you could also catch it here
        if (err) throw err;
        // success case, the file was saved
        console.log('Lyric saved!');
    });
  } // write_to_file

  ipcMain.on('WRITE_TEXT', async (event, arg) => {
    writeToFile(arg.fileName, arg.inData)
  });

Til din renderer prosessen legge denne koden.

const {ipcRenderer} = require('electron')
ipcRenderer.sendSync('WRITE_TEXT',{fileName, inData})

Som du kan se, i gjengivelsesprosessen , dette sender inp_datatil din hovedprosessen gjennom 'WRITE_TEXT' IPC kanal .

En ting her, på koden din. Du kobler DB på din renderer, og det er mulig, men dette er ikke et riktig valg. Vennligst tenke mens du har den flere renderer. Du bør flytte denne til hovedprosessen også.

Svarte 14/01/2020 kl. 05:32
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more