Blog - Hannes Pries - Webdeveloper Blog - Entwicklung mit Shopware, PHP, HTML5 und JavaScript

Shopware: Meine Config für die DEV-VM

Da ich jetzt für die Entwicklung mit Shopware unter Windows eine Ubuntu-VM. Meine Config-Datei für die VM sieht momentan so aus:

<?php return array (
'db' =>
array (
'host' => 'localhost',
'port' => '3306',
'username' => 'root',
'password' => 'root',
'dbname' => 'shopware',
),
'front' => [
'showException' => true,
'throwExceptions' => true,
'noErrorHandler' => false,
],
'phpsettings' => [
'display_errors' => 1,
],
'mail' => [
'type' => 'file',
'path' => $this->DocPath().'mails'
],
);

Damit sollte so weit alles was für die Entwicklung wichtig ist angezeigt werden und auch die Emails sollten gespeichert, aber nicht versendet werden.

FileIOToolKit neuste Version

Hier dann die neuste Version des FileIOToolKit .

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

public class FileIOToolKit {

public FileIOToolKit() {

}

public static byte[] read(String filename) throws IOException {
return read(new File(filename));
}

public static byte[] read(File file) throws IOException {
byte[] in;
try (FileInputStream fis = new FileInputStream(file);) {
in = new byte[(int) file.length()];
fis.read(in);
}
catch (Exception e) {
throw e;
}
return in;
}

public static String readString(File file) throws IOException {
return readString(file, true);
}

public static String readString(File file, boolean reConstructEndOfLines) throws IOException {
StringBuilder buf = new StringBuilder();
try (BufferedReader in = new BufferedReader(new FileReader(file))) {
String str;
while ((str = in.readLine()) != null) {
if (reConstructEndOfLines) {
buf.append(str + "\n");
}
else {
buf.append(str);
}
}
}
catch (IOException e) {
throw e;
}
return buf.toString();
}

public static List<String> readStringAsList(File file) throws IOException {
List<String> buf = new ArrayList<String>();
try (BufferedReader in = new BufferedReader(new FileReader(file))) {
String str;
while ((str = in.readLine()) != null) {
buf.add(str);
}
}
catch (IOException e) {
throw e;
}
return buf;
}

public static String readString(String filename) throws IOException {
return readString(new File(filename));
}

public static String readString(String filename, boolean reConstructEndOfLines) throws IOException {
return readString(new File(filename), reConstructEndOfLines);
}

public static void write(File file, byte[] content) throws IOException {
try (RandomAccessFile rFile = new RandomAccessFile(file, "rw")) {
rFile.write(content);
}
catch (IOException e) {
throw e;
}
}

public static void write(String filename, byte[] content) throws IOException {
write(new File(filename), content);
}

public static void writeString(String filename, String content) throws IOException {
writeString(new File(filename), content, "UTF-8");
}

public static void writeStringOld(String filename, String content) throws IOException {
writeStringOld(new File(filename), content, "UTF-8");
}

public static void writeString(String filename, String content, String encoding) throws IOException {
writeString(new File(filename), content, encoding);
}

public static void writeString(File file, String content) throws IOException {
writeString(file, content, "UTF-8");
}

public static void writeString(File file, String content, String encoding) throws IOException {
try (RandomAccessFile rFile = new RandomAccessFile(file, "rw")) {
rFile.writeBytes(content);
}
catch (IOException e) {
throw e;
}
}

public static void writeStringOld(File file, String content, String encoding) throws IOException {
try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), encoding))) {
bw.write(content);
}
catch (IOException e) {
throw e;
}
}

public static void append(File file, byte[] content) throws IOException {
try (FileOutputStream fos = new FileOutputStream(file, true)) {
fos.write(content);

}
catch (IOException e) {
throw e;
}
}

public static void append(String filename, byte[] content) throws IOException {
append(new File(filename), content);
}

public static void appendString(File file, String content) throws IOException {
appendString(file, content, "UTF-8");
}

public static void appendString(File file, String content, String encoding) throws IOException {
try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), encoding))) {
bw.write(content);
}
catch (IOException e) {
throw e;
}
}

public static void appendString(String filename, String content) throws IOException {
appendString(new File(filename), content);
}

public static void appendString(String filename, String content, String encoding) throws IOException {
appendString(new File(filename), content, encoding);
}

private static String convertByteArrayToHexString(byte[] arrayBytes) {
StringBuffer stringBuffer = new StringBuffer();
for (int ii = 0; ii < arrayBytes.length; ii++) {
stringBuffer.append(Integer.toString((arrayBytes[ii] & 0xff) + 0x100, 16).substring(1));
}
return stringBuffer.toString();
}

public static String createMD5HashOfFile(String filename) throws IOException, NoSuchAlgorithmException {
return createMD5HashOfFile(new File(filename));
}

public static String createMD5HashOfFile(File file) throws IOException, NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] content = read(file);
byte[] hash = digest.digest(content);
return convertByteArrayToHexString(hash);
}

public static String createMD5HashOfContent(byte[] content) throws IOException, NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] hash = digest.digest(content);
return convertByteArrayToHexString(hash);
}
}

Alles was man für die alltägliche Arbeit mit Dateien in Java braucht.

How to: Upload Files with JavaScript FileAPI - 3 of 3

We have out data seperated in chunks now. Now we have to write a script to send this data to the PHP-script or servlet to save it in a file. This is the elementary part of the the javascript-function and also the simple part. Because we append every chunk to the final file, we can’t work with asynchron requests. If you want to, you have to send also the number of the chunk, and also the final filesize to create a dummy-file and replace the part of the sent chunk. For the javascript the changes are no this big, but the server-side script become more complex.

So.. we will use the synchrone style and work with a simple for-loop to run through our array with the data chunks.

var result=null;
for(var i=0;i<chunks.length;i++){
var last=false;
if(i==(chunks.length-1)){
last=true;
}
result=uploadFileChunk(chunks,filenamePrefix+file.name,url,params,last);
}
return result;

Only the result of the request of the last chunk is returned. Because it is the chunk where the magic (copy from temp-folder to real target folder and create and save entity to database, etc) happens.

I send add a prefix to the filename to create a filename like userid+prefix+filename+fileextension (like *.part or somethin like this). So a user can upload more than one file with the same filename, without cause problems on server side.

But you should also send the original filename as something like "clearname". In this example you can add it to die params-array (params["clearname"]=file.name;) and use it as filename in the db-entity to set this name in header-data on download of this file or in lists of the uploaded files.

This is the code where the upload is peformed. It is a FormData-Object (like a form in HTML) and is send via a synchron AJAX-Request.

How to: Upload Files with JavaScript FileAPI - 2 of 3

Now we have a file-object, we need to split it in small chunks to upload this chunks one by one. JavaScript have the ability to work with files. It can’t access the filesystem directly, but the open- and save-dialogs will do every thing we need. To save data for more than one session you can use the indexeddb. But here we need only open,save and drag and drop.

function createChunksOfFile(file,chunkSize){
var chunks=new Array();

var filesize=file.size;

var counter=0;
while(filesize>counter){
var chunk=file.slice(counter,(counter+chunkSize));
counter=counter+chunkSize;

chunks[chunks.length]=chunk;
}

return chunks;
}

The method is very simple. The loop runs as long as the copied size is smaller as the size of the file. With slice(from,to) you have to set the start- and the endpoint, that is read (in bytes). If the endpoint behind the real end of the file no execption is thrown and only the existing part will be copied. That makes it very easy to us. With every run of the loop we add 250000 to the copied-size till our copied-size is greater than the file-size. In ervery run of the loop we copy/slice the bytes from copied-size to copied-size + 250000 and add this slice-chunk to the output array.

Finally we get an array with alle the sliced chunks of the file in correct order.

Yes.. you can calculate the needed count of chunks and than use a for-loop and calculate the start and end for every part. Works great too… but i did it the other way.

var chunks=createChunksOfFile(file,250000);

So we have all chunks each ~250KB. 1MB should have ~4 Parts. Yes.. it’s 1024Bytes per 1KB.. but we keep it simple :-)

User	annonyme	Date	2015-12-22 21:16
Tags	chunks, english, file, fileapi, hannes pries, javascript, size, slice, upload

Hannes Pries - Web/Shopware/JavaScript-Developer BlogWeil es immer eine simple Lösung gibt!

Hannes Pries - Web/Shopware/JavaScript-Developer Blog
Weil es immer eine simple Lösung gibt!