How to use

close

function

in

WriteStream

function getPipInstaller() {
 // install pip
 return new Promise((resolve, reject) => {
  const pipFilePath = path.join(__dirname, "get-pip.py");
  if (fs.existsSync(pipFilePath)) return resolve(pipFilePath);

  const file = fs.createWriteStream(pipFilePath);
  const request = https.get(pipUrl, function(response) {
   response.pipe(file);
   file.on("finish", function() {
    file.close(() => {
     resolve(pipFilePath);
    });
   });
   file.on("error", function(err) {
    fs.unlink(pipFilePath);
    reject(err);
   });
  });
 });
}

function downloadFile(url, dest, cb) {
  console.log('Downloading %s', url);
  var file = fs.createWriteStream(dest);

  var req = request.get(url);
  req.pipe(file).on('error', function(err) { // Handle errors
    fs.unlink(dest); // Delete the file async. (But we don't check the result)
    if (cb) cb(err.message);
  });

  file.on('finish', function() {
    file.close(cb);  // close() is async, call cb after close completes.
  });
}

// 파일 다운로드하기 --- (※3)
function downloadPromise (url, savepath) {
 return new Promise((resolve, reject) => {
  const http = require('http')
  const fs = require('fs')
  if (fs.existsSync(savepath)) return resolve()
  const outfile = fs.createWriteStream(savepath)
  http.get(url, (res) => {
   res.pipe(outfile)
   res.on('end', () => {
    outfile.close()
    resolve()
   })
  })
  .on('error', (err) => reject(err))
 })
}

const save = (vpns) => {
 return new Promise((resolve, reject) => {
  const writer = fs.createWriteStream(filePath, { overwrite: true });
  writer
   .on('open', () => {
    vpns = vpns.sort((a, b) => (b.score - a.score));
    const chain = vpns.slice(0, 2).map((vpn) => {
     return new Promise(resolve => writer.write(vpn.config, resolve));
    });

    Promise.all(chain)
     .then(() => writer.close());
   })
   .on('error', reject)
   .once('close', resolve);
 });
}

const downloadAndSetWallpaper = uri =>
 process.platform !== 'win32'
  ? null
  : new Promise((resolve, reject) => {
    const savePath = join(tempFolder, 'bg.jpg');
    const file = createWriteStream(savePath);
    const request = get(uri, res => {
     res.pipe(file);
     res.once('end', () => {
      if (res.statusCode !== 200) {
       file.destroy(new Error(`Server returned status code ${res.statusCode}`));
      } else file.close();
     });
    });
    const onError = err => {
     file.removeAllListeners();
     request.removeAllListeners();
     reject(err);
    };
    file.once('close', () => {
     file.removeAllListeners();
     resolve(wallpaper.set(savePath));
    });
    file.once('error', onError);
    request.once('error', onError);
   })

//writeStream.on('error', (error) => console.error(error))
readStream
  .pipe(split(JSON.parse))
  .on('data', (record) => {
    const balance = record.balance.replace('$', '').replace(',', '');
    const value = parseFloat(balance);

    if (record.age > 35) {
      const report = JSON.stringify({
        contact_name: record.name,
        company: record.company,
        usd_value: formatCurrency(value),
        ngn_value: formatCurrency((value * exchangeRate), 'NGN'),
      });
      writeStream.write(`${report}\n`);
    }

    total += value;
    occurences++;
  })
  .on('end', () => {
    console.log({
      total: total.toFixed(2),
      average_balance: (total/occurences).toFixed(2),
      accountCount: occurences
    });
    writeStream.close();
  })
  .on('error', (error) => console.error(error));

fs.stat(file.path, (err, stat) => {
    if (stat && stat.isFile()) {
     let rf = readline.createInterface({
      // create file read stream
      input: fs.createReadStream(file.path),
      terminal: false
     });
     rf.on('error', (err) => { console.log(err); });
     let wf = fs.createWriteStream(file.destination + file.originalname);
     rf.on('line', (line) => {
      if (line.match(/<ModelFile>/)) {
       line = line.replace(/'<ModelFile>'/, file.destination + file.originalname);
      }
      wf.write(line + '\n');
     });
     rf.on('close', () => {
      wf.close();
      res = {
       msg: 'Great! You could include this lib with path: ' + file.destination + file.originalname,
       type: 'success'
      }
      resolve(res);
     });
    } else {
     reject();
    }
   })

fs.mkdir(folder, function (err) {
 if (err && err.code !== 'EEXIST') throw err;

 fs.stat(fromPath, function (err, stats) {
  if (err) throw err;
  const filesize = stats.size;

  const readStream = fs.createReadStream(fromPath, options);
  readStream.on('error', function (err) {
   console.error('Please provide valid file :', err);
  });

  const writeStream = fs.createWriteStream(toPath, options);
  writeStream.on('error', function (err) {
   console.error('Cannot copy to given file :', err);
  });

  let dataRead = 0;
  readStream.on('data', chunk => {
   dataRead += chunk.length;
   console.log(`${Math.floor((dataRead * 100) / filesize)} %`);
   writeStream.write(chunk);
  });
  readStream.on('close', () => {
   writeStream.close();
  });
 });
});

response.pipe(file);
file.on('finish', function () {
  file.close(cb);
  console.log(chalk.green.bold("Subtitles downloaded."));
  peerflix_subtitle = dest;

 writeStream.on('finish', () => {
  console.log('') // fix stdout
  writeStream.close(resolve)
 })
})

let lineCount = 1;
let stage = fs.createWriteStream(stagePath).on('error', function (err) {
  stage.close();
  console.log(err);
  process.send(['import-failed', 'temp']);// mainWindow.webContents.send('import-failed', 'temp');
    })
    .on("error", function (err) {
      stage.close();
      console.log(err);
      process.send(['import-failed', 'read']);// mainWindow.webContents.send('import-failed', 'read');
    })
    .on("end", function () {
      stage.close();
    });
}).on("close", function () {

  response.pipe(file)
} else {
  file.close()
file.close()
file.close()

s.close(() => {
 resolve(targetFullFileName);
});

function getPipInstaller() {
 // install pip
 return new Promise((resolve, reject) => {
  const pipFilePath = path.join(__dirname, "get-pip.py");
  if (fs.existsSync(pipFilePath)) return resolve(pipFilePath);

  const file = fs.createWriteStream(pipFilePath);
  const request = https.get(pipUrl, function(response) {
   response.pipe(file);
   file.on("finish", function() {
    file.close(() => {
     resolve(pipFilePath);
    });
   });
   file.on("error", function(err) {
    fs.unlink(pipFilePath);
    reject(err);
   });
  });
 });
}

// 파일 다운로드하기 --- (※3)
function downloadPromise (url, savepath) {
 return new Promise((resolve, reject) => {
  const http = require('http')
  const fs = require('fs')
  if (fs.existsSync(savepath)) return resolve()
  const outfile = fs.createWriteStream(savepath)
  http.get(url, (res) => {
   res.pipe(outfile)
   res.on('end', () => {
    outfile.close()
    resolve()
   })
  })
  .on('error', (err) => reject(err))
 })
}