export function uploadImage(req, res) {
const options = s3({
dirname: 'uploads/images',
bucket: 'nasedkinbadanina',
secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
accessKeyId: process.env.AWS_ACCESS_KEY_ID,
region: 'eu-west-1',
filename: (req, file, cb) => {
cb(null, (Math.random().toString(36)+'00000000000000000').slice(2, 10) + Date.now() + path.extname(file.originalname));
}
})
const uploading = multer({ storage: options }).array('file');
uploading(req, res, err => {
let files = []
console.log(err)
const p1 = new Promise((resolve, reject) => {
req.files.map((file) => {
files.push({key:file.key.replace("uploads/images/", "")});
})
resolve(files);
});
p1.then((files) => res.json(files))
p1.catch(err => {
res.status(400);
res.json({error: err, event: req.body});
});
})
}
function storeMediaStream (app){
var upload = multer({
storage: s3({
dirname:'VenueImages',
bucket: 'meetsites-images',
secretAccessKey: aws_creds.secretAccessKey,
accessKeyId: aws_creds.accessKeyId,
region: 'us-east-1',
params: {ContentType: "image/jpeg"}
})
});
// var upload = multer({dest: './uploads'});
// Got to add some filters on the types of files people need to upload.
app.get('/imgUpload', function(req, res, next){
res.render('imgUpload', {layout: false, name: req.session.name});
});
app.post('/imgUpload', upload.array('photos', 10), function(req, res, next){
// var fsImpl = new S3FS('meetsites-images/VenueImages', options);
console.log('req.files:'+JSON.stringify(req.files));
// console.log('req.file:'+JSON.stringify(req.file));
console.log(req.body); // form fields
console.log(req.files); // fo
// add the code to update the mongoDB object with the file Names and Venue Name. TBD
manageVenues.addImagesToVenues(req.files, req.body.venues); // having this venueName here requires that I show list of registered venues for this host
res.send ('done');
});
}
/****************************
* S3 Storage configuration *
****************************/
aws.config.update({
accessKeyId: process.env.FOI_AMAZON_S3_KEY_ID,
secretAccessKey: process.env.FOI_AMAZON_S3_ACCESS_KEY
});
aws.config.region = "ap-southeast-1";
var s3 = new aws.S3();
var upload = multer({
storage: multerS3({
s3: s3,
acl: 'public-read',
bucket: 'feedonideas.com',
key: function (req, file, cb) {
var ext = path.extname(file.originalname);
cb(null, 'topic_covers/' + Date.now().toString() + ext);
}
}),
limits: {
fileSize: 2 * 1024 * 1024 //2 MB
}
});
const topicRoutes = function(app){
app.get('/topics', function(req, res){
topicController.getAvailableTopics(req.user, (error, model)=> {
if(!error) res.render('topics', {title: "Public Topics", publicTopics: model, userProfile: req.user });
var upload = multer({
storage: s3({
// the folder within the bucket
dirname: s3Config.dirname,
// set this to your bucket name
bucket: s3Config.bucket,
// your AWS keys
secretAccessKey: s3Config.secretAccessKey,
accessKeyId: s3Config.accessKeyId,
// the region of your bucket
region: s3Config.region,
// IMPORTANT: set the mime type to that of the file
contentType: function(req, file, next) {
next(null, file.mimetype);
},
// IMPORTANT: set the file's filename here
// ALWAYS CHANGE THE FILENAME TO SOMETHING RANDOM AND UNIQUE
// I'm using uuid (https://github.com/defunctzombie/node-uuid)
filename: function(req, file, next) {
// Get the file extension from the original filename
var ext = '.' + file.originalname.split('.').splice(-1)[0];
// create a random unique string and add the file extension
var filename = uuid.v1() + ext;
next(null, filename);
}
})
});
router.post('/register', upload.single('avatar'), authenticationController.register);
import multer from 'multer';
import multerS3 from 'multer-s3';
import aws from 'aws-sdk';
aws.config.update({
accessKeyId: process.env['AWS_ACCESS_KEY_ID'],
secretAccessKey: process.env['AWS_SECRET_ACCESS_KEY'],
region: process.env['AWS_REGION']
});
const awsS3 = new aws.S3();
const uploadFileToAwsS3 = multer({
storage: multerS3({
s3: awsS3,
bucket: process.env['AWS_BUCKET_NAME'],
acl: 'public-read',
metadata: (req, file, cb) => {
cb(null, { fieldName: file.fieldname });
},
// we are making a timestamp of a current time and saving this file under this name.
key: (req, file, cb) => {
cb(null, Date.now().toString());
}
})
});
export default uploadFileToAwsS3;
function bufferToHash(buffer) {
const hash = crypto.createHash('sha256');
hash.update(buffer);
return hash.digest('hex');
}
const uploader = multer({
storage: multer_s3({
s3: aws.s3,
bucket: conf.get('service.aws.s3_asset_bucket'),
acl: 'public-read',
contentType: multer_s3.AUTO_CONTENT_TYPE,
// contentDisposition: `inline; filename=file`,
cacheControl: 'max-age=36000',
metadata: function (req, file, cb) {
// each will be prefix with 'x-amz-meta-'
cb(null, {
'original-name': file.originalname,
});
},
key: function (req, file, cb) {
cb(null, `${bufferToHash(file.fieldname + Date.now())}.${mime.extension(file.mimetype)}`);
}
}),
// dest: os.tmpdir(),
fileFilter: (req, file, cb) => {
if ([
'image/jpeg',
'image/png',
'image/gif',
// 'application/pdf'
var multerS3 = require('multer-s3');
AWS.config.loadFromPath('./aws-config.json');
// assume you already have the S3 Bucket created, and it is called ierg4210-shopxx-photos
var photoBucket = new AWS.S3({params: {Bucket: 'tip-photos-bucket'}});
var sampleBucket = new AWS.S3({params: {Bucket: 'tip-samples-bucket'}});
console.log("Photo Bucket is")
console.log(photoBucket);
var upload = "";
if (runningProduction) {
upload = multer({storage: multerS3({
s3: photoBucket,
bucket: 'tip-photos-bucket',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, Date.now().toString())
}
})
}).single('file');
uploadSample = multer({storage: multerS3({
s3: sampleBucket,
bucket: 'tip-samples-bucket',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, Date.now().toString())
require('./rest/rest-users')(router);
require('./rest/rest-sections')(router);
require('./rest/rest-search')(router);
require('./rest/rest-lang')(router);
var bucketSecret = process.env.S3_BUCKET_SECRET;
var bucketAccessKey = process.env.S3_ACCESS_KEY;
console.log('s3 data: ', bucketSecret, bucketAccessKey);
var upload = multer({
storage: s3({
dirname: 'public/uploads',
bucket: 'digitalurbanstudiesbucket',
secretAccessKey: bucketSecret,
accessKeyId: bucketAccessKey,
region: 'us-east-1',
filename: function (req, file, cb) {
cb(null, Date.now()+file.originalname);
}
})
});
router.post('/uploadAndReturnHtml', upload.single('upload'), function(req, res, next) {
console.log('uploading item: ');
console.log('uploading item ', req.file.key);
var path = 'https://s3.amazonaws.com/digitalurbanstudiesbucket/'+req.file.key;
console.log('item uploaded ', path);
html = "";
html += "<script type='text/javascript'>";
var aws = require('aws-sdk');
var Ngo = require('../models/ngo');
var User = require('../models/user');
var Project = require('../models/project');
var sid = require('shortid');
var generatePassword = require('password-generator');
var mailjet = require('./mailjet');
var s3 = new aws.S3({signatureVersion: 'v4'});
var s3Sotrage = multerS3({
s3: s3,
bucket: 'engage-site-nns',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, Date.now() + '-' + file.originalname);
}
});
var localStorage = multer.diskStorage({
destination: function (req, file, cb) {
cb(null, 'uploads/')
},
filename: function (req, file, cb) {
cb(null, Date.now() + '-' + file.originalname)
}
});
if (config.fileStorage == 's3') {
// });
//s3 uploads
var multerS3 = require('multer-s3');
var aws = require('aws-sdk');
var s3 = new aws.S3();
var upload = multer({
storage: multerS3({
s3: s3,
bucket: 'primedigitalplantid',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, folder + Date.now().toString())
}
})
});
router.post('/', upload.single('file'), function(req, res) {
var newUpload = {
comment: req.body.comment,
created: Date.now(),
user: req.body.user,
secretAccessKey: 'YOUR_ACCESS_SECRET_KEY',
accessKeyId: 'YOUR_ACCESS_KEY_ID',
region: 'us-east-1'
});
const app = express();
const s3 = new aws.S3();
app.use(bodyParser.json());
const upload = multer({
storage: multerS3({
s3: s3,
acl: 'public-read',
bucket: 'YOUR_BUCKET_NAME',
key: function (req, file, cb) {
console.log(file);
cb(null, file.originalname); //use Date.now() for unique file keys
}
})
});
//open http://localhost:3000/ in browser to see upload form
app.get('/', (req, res) => {
res.sendFile(__dirname + '/index.html');
});
//used by upload form
app.post('/upload', upload.array('upl',1), (req, res, next) => {
res.send("Uploaded!");
});
// instancia de cliente
var client = mygram.createClient(config.client)
var s3 = new aws.S3({
accessKeyId: config.aws.accessKey,
secretAccessKey: config.aws.secretKey
})
/* https://www.npmjs.com/package/multer-s3 */
var storage = multerS3({
s3: s3,
bucket: 'mygram',
acl: 'public-read', // access control list (visibilidad de los archivos)
metadata : function (req, file, cb) {
cb(null, { fieldName: file.fieldname })
},
key: function (req, file, cb) {
cb(null, +Date.now() + '.' + ext(file.originalname))
}
})
// middleware de upload
var upload = multer({ storage: storage }).single('picture') /*le pasamos picture que es el atributo name que lleva el input detipo file en el form*/
var app = express();
/*
* queremos que express sea capaz de hacer parse de peticions http que contengan un json,
* de esta manera cualquier peticion que llegue con un json vamos a poder obtener el obj
* json en el body de nuestro request de una manera ya serializada
var router = express.Router();
var passport = require('passport');
var localStrategy = require('passport-local').Strategy;
var aws = require('aws-sdk');
var multer = require('multer');
var multerS3 = require('multer-s3');
var s3 = new aws.S3({params: {Bucket: 'samsblog', Key: 'SUtqEuhMVINcwwsKexZfwVPgS+yr/jsrIb144YkD'}});
aws.config.update({accessKeyId: process.env.AWS_ACCESS_KEY_ID, secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY});
var upload = multer({
storage: multerS3({
s3: s3,
bucket: 'samsblog',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, "avatars/" + Date.now().toString())
}
}),
fileFilter: function (req, file, cb) {
if (file.mimetype !== 'image/jpeg') {
var err;
return cb(
err = {msg:'Wrong file type. Only JPG files may be used as avatars.'}
)
}
cb(null, true)
var multer = require('multer');
var s3 = require('multer-s3');
var uuid = require('node-uuid');
var pictureUpload = multer({
storage: s3({
dirname: 'uploads/photos',
bucket: process.env.BUCKET,
secretAccessKey: process.env.S3ACCESSKEY,
accessKeyId: process.env.S3KEYID,
region: 'us-east-1',
filename: function (req, file, cb) {
var filename = uuid.v1() + '.' + file.mimetype.substring(file.mimetype.indexOf('/')+1);
req.S3url = 'https://s3-us-west-2.amazonaws.com/langwang1/uploads/photos/' + filename;
cb(null, filename);
}
}),
fileFilter : fileFilter,
limits : {fileSize : 1024 * 1024 * 1024}
});
function fileFilter(req, file, cb) {
if(file.mimetype.indexOf("image") == -1){
req.uploadToS3 = false;
cb(null,false);
}else {
req.uploadToS3 = true;
cb(null,true);
}
}
exports.changeProfilePicture = function (req, res) {
var user = req.user;
var message = null;
var upload, fileKey;
// Upload locally if not production.
if(process.env.NODE_ENV !== 'production'){
upload = multer(config.uploads.profileUpload).single('newProfilePicture');
} else {
// Production - upload to s3.
fileKey = 'profile_pic_' + Date.now().toString();
upload = multer({
storage: multerS3({
s3: s3,
bucket: config.s3bucket,
metadata: function (req, file, cb) {
cb(null, { fieldName: file.fieldname });
},
key: function (req, file, cb) {
cb(null, fileKey);
}
})
}).single('newProfilePicture');
}
// Filtering to upload only images
var profileUploadFileFilter = require(path.resolve('./config/lib/multer')).profileUploadFileFilter;
upload.fileFilter = profileUploadFileFilter;
if (user) {
upload(req, res, function (uploadError) {
if(uploadError) {
return res.status(400).send({
message: 'Error occurred while uploading profile picture'
});
} else {
//Success, Delete old profileImg if exists.
if(process.env.NODE_ENV){
fileKey = req.file.filename;
} else if(user.profileImageURL){
s3.deleteObjects({
Bucket: config.s3bucket,
Delete: {
Objects: [
{ Key: user.profileImageURL }
]
}
}, function(err, data) {
if (err)
return console.log(err);
console.log('Old profile image removed safely.');
});
}
//Replace imgurl on user with new one.
user.profileImageURL = fileKey;
user.save(function (saveError) {
if (saveError) {
return res.status(400).send({
message: errorHandler.getErrorMessage(saveError)
});
} else {
req.login(user, function (err) {
if (err) {
res.status(400).send(err);
} else {
res.json(user);
}
});
}
});
}
});
} else {
res.status(400).send({
message: 'User is not signed in'
});
}
};
exports.changeProfilePicture = function (req, res) {
var user = req.user;
var existingImageUrl;
var multerConfig;
if (useS3Storage) {
multerConfig = {
storage: multerS3({
s3: s3,
bucket: config.aws.s3.bucket,
acl: 'public-read'
})
};
} else {
multerConfig = config.uploads.profile.image;
}
// Filtering to upload only images
multerConfig.fileFilter = require(path.resolve('./config/lib/multer')).imageFileFilter;
var upload = multer(multerConfig).single('newProfilePicture');
if (user) {
existingImageUrl = user.profileImageURL;
uploadImage()
.then(updateUser)
.then(deleteOldImage)
.then(login)
.then(function () {
res.json(user);
})
.catch(function (err) {
res.status(422).send(err);
});
} else {
res.status(401).send({
message: 'User is not signed in'
});
}
function uploadImage() {
return new Promise(function (resolve, reject) {
upload(req, res, function (uploadError) {
if (uploadError) {
reject(errorHandler.getErrorMessage(uploadError));
} else {
resolve();
}
});
});
}
function updateUser() {
return new Promise(function (resolve, reject) {
user.profileImageURL = config.uploads.storage === 's3' && config.aws.s3 ?
req.file.location :
'/' + req.file.path;
user.save(function (err, theuser) {
if (err) {
reject(err);
} else {
resolve();
}
});
});
}
function deleteOldImage() {
return new Promise(function (resolve, reject) {
if (existingImageUrl !== User.schema.path('profileImageURL').defaultValue) {
if (useS3Storage) {
try {
var { region, bucket, key } = amazonS3URI(existingImageUrl);
var params = {
Bucket: config.aws.s3.bucket,
Key: key
};
s3.deleteObject(params, function (err) {
if (err) {
console.log('Error occurred while deleting old profile picture.');
console.log('Check if you have sufficient permissions : ' + err);
}
resolve();
});
} catch (err) {
console.warn(`${existingImageUrl} is not a valid S3 uri`);
return resolve();
}
} else {
fs.unlink(path.resolve('.' + existingImageUrl), function (unlinkError) {
if (unlinkError) {
// If file didn't exist, no need to reject promise
if (unlinkError.code === 'ENOENT') {
console.log('Removing profile image failed because file did not exist.');
return resolve();
}
console.error(unlinkError);
reject({
message: 'Error occurred while deleting old profile picture'
});
} else {
resolve();
}
});
}
} else {
resolve();
}
});
}
function login() {
return new Promise(function (resolve, reject) {
req.login(user, function (err) {
if (err) {
res.status(400).send(err);
} else {
resolve();
}
});
});
}
};
}
done();
});
}); // end removeFave
////////////////////////////////////////////////////////////
// UPLOAD IMAGES ROUTES //
////////////////////////////////////////////////////////////
var upload = multer({
storage: multerS3({
s3: s3,
bucket: 'prime-digital-academy-playbow',
acl: 'public-read',
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
// file name generation
cb(null, Date.now().toString());
}
})
}); // end multer upload
// upload post route
router.post('/uploads', upload.single('file'), function(req, res) {
console.log('in post uploads:', req.file);
res.send(req.file);
});
module.exports = router;
var router = express.Router();
var fs = require('fs');
var Upload = require('../models/upload');
var multer = require('multer');
var multerS3 = require('multer-s3');
var aws = require('aws-sdk');
var s3 = new aws.S3();
var upload = multer({
storage: multerS3({
s3: s3,
bucket: process.env.S3_BUCKET_NAME,//alternately, if you are not using a .env file you can just use a string for the name of your bucket here, 'your-bucket-name'
acl: 'public-read',//default is private, set to public-read is so the public can view your pictures
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, Date.now().toString())
}
})
});
//upload.single('file') is the line that uploads to AWS, the rest is MongoDB
router.post('/', upload.single('file'), function(req, res) {
var newUpload = {
created: Date.now(),
file: req.file,
comment: req.body.comment,
console.log(ACCESS_KEY);
console.log(SECRET_ACCESS_KEY);
// Load the AWS SDK for Node.js
const AWS = require('aws-sdk');
// Create S3 service object
const S3 = new AWS.S3({
accessKeyId: ACCESS_KEY,
secretAccessKey: SECRET_ACCESS_KEY,
region: 'us-east-1'
});
const upload = multer({
storage: multerS3({
s3: S3,
bucket: BUCKET_NAME,
metadata: function (req, file, cb) {
cb(null, {
fieldName: file.fieldname
});
},
key: function (req, file, cb) {
cb(null, Date.now().toString());
}
})
});
module.exports = upload;
var express = require('express');
var router = express.Router();
var fs = require('fs');
var multer = require('multer');
var aws = require('aws-sdk');
var multerS3 = require('multer-s3')
var s3 = new aws.S3();
var upload = multer({
storage: multerS3({
s3: s3,
bucket: 'raisable',
acl: 'public-read',
key: function (req, file, cb) {
cb(null, fileName = Date.now().toString());
}
})
})
router.post('/', upload.single('file'), function(req, res, next) {
res.send(fileName);
console.log(fileName);
});
module.exports = router;
var multerS3 = require('multer-s3')
var Entity = require('./roofer.model')
var User = require('../users/users.model')
var s3 = new AWS.S3({
accessKeyId: config.AWS_ID,
secretAccessKey: config.AWS_KEY,
})
var upload = multer({
storage: multerS3({
s3: s3,
bucket: 'rooferx',
acl: 'public-read',
contentType: multerS3.AUTO_CONTENT_TYPE,
metadata: function(req, file, cb) {
cb(null, { fieldName: file.fieldname })
},
key: function(req, file, cb) {
cb(null, Date.now().toString())
},
}),
})
//var cpUpload = upload.single('resume');
// var upload = multer() upload.array(),
var router = express.Router()
router.use(authUtils.ensureAuthenticated) //auth only appied for following paths, not the paths above
router.get('/', controller.index)
router.get('/:id', controller.show)
router.post('/', controller.create)
router.put('/:id', controller.update)
var express = require('express'),
bodyParser = require('body-parser'),
multer = require('multer'),
s3 = require('multer-s3');
var app = express();
app.use(bodyParser.json());
var upload = multer({
storage: s3({
dirname: '/',
bucket: 'bucket-name',
secretAccessKey: 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
accessKeyId: 'XXXXXXXXXXXXXXX',
region: 'us-east-1',
filename: function (req, file, cb) {
cb(null, file.originalname); //use Date.now() for unique file keys
}
})
});
//open in browser to see upload form
app.get('/', function (req, res) {
res.sendFile(__dirname + '/index.html');
});
//use by upload form
app.post('/upload', upload.array('upl'), function (req, res, next) {
res.send("Uploaded!");
});
var client = platzigram.createClient(config.client);
var s3 = new aws.S3({
accessKeyId: config.aws.accessKey,
secretAccessKey: config.aws.secretKey,
endpoint: 's3-eu-central-1.amazonaws.com',
signatureVersion: 'v4',
region: 'eu-central-1'
})
var storage = multerS3({
s3: s3,
bucket: 'platzigram-aitoribanez',
acl: 'public-read',
metadata: function(req, file, cb) {
cb(null, {fieldName: file.fieldname})
},
key: function(req, file, cb) {
cb(null, +Date.now() + '.' + ext(file.originalname))
}
})
/* var storage = multer.diskStorage({
destination: function (req, file, cb) {
cb(null, './uploads')
},
filename: function (req, file, cb) {
cb(null, +Date.now() + '.' + ext(file.originalname))
}
}) */
var multer = require('multer'),
multerS3 = require('multer-s3'),
AWS = require('aws-sdk')
config = require('../../config');
AWS.config.update({
accessKeyId: config.aws.accessKeyId,
secretAccessKey: config.aws.secretAccessKey,
region: config.aws.region
});
var s3 = new AWS.S3();
var uploader = multer({
storage: multerS3({
s3: s3,
bucket: config.aws.bucket,
contentType: multerS3.AUTO_CONTENT_TYPE,
metadata: function (req, file, cb) {
cb(null, {fieldName: file.fieldname});
},
key: function (req, file, cb) {
cb(null, Date.now().toString())
}
})
});
module.exports = uploader;
const aws = require('aws-sdk');//Library for communicating with the aws(keys)
const multer = require('multer');//Library to aprove images
const multers3 = require('multer-s3');
const s3 = new aws.S3({accessKeyId: 'AKIAJZ5YUVKTMPGSL7JQ', secretAccessKey: 'UwZ/DUb1PNMRnrys8B95ng1210eo+UpM13CiG9Jy'});
//Communicate with our story bucket and the secret key
const faker = require('faker');
const checkJWT = require('../middlewares/check-jwt');
const upload = multer({
storage: multers3({
s3:s3,
bucket: 'amazonowebapplication',
metadata: function(req, file, cb){
cb(null, {fieldName: file.fieldName});
},
key: function(req, file, cb){
cb(null, Date.now().toString());
}
})
});
router.route('/products')
.get(checkJWT, (req, res, next) =>{
Product.find({owner: req.decoded.user._id})
.populate('owner')
.populate('category')
.exec((err, products) =>{
if(products){
res.json({
success: true,