return __awaiter(this, void 0, void 0, function* () {
const src = path.join(this.getResourcesDir(appOutDir), "app");
let glob = null;
const files = (yield new bluebird_1.Promise((resolve, reject) => {
glob = new glob_1.Glob("**/*", {
cwd: src,
// dot: true as in the asar by default
dot: true,
ignore: "**/.DS_Store"
}, (error, matches) => {
if (error == null) {
resolve(matches);
} else {
reject(error);
}
});
})).map(it => path.join(src, it));
const stats = yield bluebird_1.Promise.map(files, it => {
// const stat = glob!.statCache[it]
// return stat == null ? lstat(it) : <any>stat
// todo check is it safe to reuse glob stat
return fs_extra_p_1.lstat(it);
});
const metadata = {};
for (let i = 0, n = files.length; i < n; i++) {
const stat = stats[i];
metadata[files[i]] = {
type: stat.isFile() ? "file" : stat.isDirectory() ? "directory" : "link",
stat: stat
};
}
yield bluebird_1.Promise.promisify(asar_1.createPackageFromFiles)(src, path.join(this.getResourcesDir(appOutDir), "app.asar"), files, metadata, options);
yield fs_extra_p_1.remove(src);
});
.then((recipient) => {
if ((recipient || {}).hasOwnProperty('email')) {
return Promise.reject(new RecipientAlreadyExists(`The recipient ${email} already exists`));
} else {
return Promise.resolve(email);
}
});
trySend(value: Promise<T> | T): boolean {
this.outbound = this.outbound.filter((it) => it.promise.isPending())
if (this.outbound.length == 0) return false
var receiver = sample(this.outbound)
var other = Promise.resolve(value)
receiver.resolve(Promise.resolve(value))
return true
}
value: function find(prefix) {
var dict = this.dicts[prefix];
if (!dict) {
return _bluebird.Promise.resolve(null);
}
return _bluebird.Promise.resolve(dict);
}
}).catch((error) => {
logger().warn('SendEmailService._checkReputation error occurred:', error);
if (error === 'Bad reputation') {
// return this.queue.purgeQueue().then(() => Promise.reject(error));
return Promise.reject(error);
}
// Being conservative since this should not break send emails proccess
return Promise.resolve({});
});
/**
* Returns a promise for when the provided value has been received.
*
* @param {T} value
* @return {Promise<void>}
*/
send(value: Promise<T> | T): Promise<void> {
if (this.done) return Promise.reject(new TypeError(Channel.SEND_ON_CLOSED))
if (this.trySend((value:any))) {
return Promise.resolve()
} else {
var sender = new Sender(Promise.resolve(value))
this.inbound.push(sender)
return sender.promise
}
}
yield promise_1.executeFinally(packager.build(), errorOccurred => {
if (errorOccurred) {
for (let task of publishTasks) {
task.cancel();
}
return bluebird_1.Promise.resolve(null);
} else {
return bluebird_1.Promise.all(publishTasks);
}
});
it("can pass a resolver as a function object", (done) => {
let p = new Promise(function(resolve, reject) {
setTimeout(resolve, 10);
});
p.then((message) => {
console.log("Tock!", message);
done();
})
});
return passthru({ token: token }).then(function (body) {
if (body.error) {
return PromiseA.reject(body.error);
}
if (!body.jar) {
return PromiseA.reject(new Error("bad credentials"));
}
return body;
});
// next :: () =>
// | { done: true, value: Promise<T> }
// | { done: false, value: Promise<void> }
// next :: (value: Promise<T> | T) =>
// | { done: boolean, value: Promise<void> }
next(value?: Promise<T> | T): AsynchronousIteratorResult<T> {
var result
if (this.done) {
result = Promise.resolve()
} else if (arguments.length == 0) {
result = this.receive()
} else {
result = this.send(Promise.resolve(value))
}
return { done: this.done, value: (result:any) }
}
return this._invokeGetUserData().then((response) => {
const userData = JSON.parse(response.Payload);
const reputationData = userData.reputationData;
this.reputation = reputationData.reputation;
logger().debug('SendEmailService._checkReputation user reputation:', reputationData);
if (reputationData.reputation < reputationData.minimumAllowedReputation) {
logger().error('SendEmailService._checkReputation, Bad Reputation detected', reputationData.reputation, 'stopping...');
return Promise.reject('Bad reputation');
}
return Promise.resolve({});
}).catch((error) => {
return passthru(opts).then(function (body) {
if (body.error) {
console.error('Error with login');
console.error(body.error);
return PromiseA.reject(body.error);
}
console.log(body);
if (!body.jar) {
return PromiseA.reject(new Error("bad credentials"));
}
return body;
});
return __awaiter(this, void 0, void 0, function* () {
if (bundledCertKeychainAdded == null) {
bundledCertKeychainAdded = createCustomCertKeychain();
}
yield bundledCertKeychainAdded;
const keychainName = yield tmpDir.getTempFile(".keychain");
const certLinks = [cscLink];
if (cscILink != null) {
certLinks.push(cscILink);
}
const certPaths = new Array(certLinks.length);
const keychainPassword = crypto_1.randomBytes(8).toString("hex");
return yield promise_1.executeFinally(bluebird_1.Promise.all([bluebird_1.Promise.map(certLinks, (link, i) => downloadCertificate(link, tmpDir).then(it => certPaths[i] = it)), bluebird_1.Promise.mapSeries([["create-keychain", "-p", keychainPassword, keychainName], ["unlock-keychain", "-p", keychainPassword, keychainName], ["set-keychain-settings", "-t", "3600", "-u", keychainName]], it => util_1.exec("security", it))]).then(() => importCerts(keychainName, certPaths, [cscKeyPassword, cscIKeyPassword].filter(it => it != null))), () => promise_1.all(certPaths.map((it, index) => certLinks[index].startsWith("https://") ? fs_extra_p_1.deleteFile(it, true) : bluebird_1.Promise.resolve())));
});
}, function (error) {
delete context.cancel;
if (!(0, _isUndefined3.default)(error)) {
error = error instanceof Error ? error : new Error((0, _toString3.default)(error));
error.rollbackErrors = [];
(0, _reduceRight3.default)(Array.from(executed.values()), function (result, step) {
var rollback = (0, _bind3.default)(step.rollback, (0, _extend3.default)({}, context, step), error);
return result.then(function () {
return _bluebird.Promise.try(rollback).catch(function (err) {
return error.rollbackErrors.push(err);
});
});
}, _bluebird.Promise.resolve()).finally(function () {
logger.info('Dispatch failed: %s', error);
steps.toArray().reduce(function (result, step) {
var failure = (0, _bind3.default)(step.failure, (0, _extend3.default)({}, context, step), error);
return result.finally(function () {
return _bluebird.Promise.try(failure);
});
}, _bluebird.Promise.resolve()).finally(function () {
resolve(new WorkflowResult({
status: Workflow.States.FAILED,
executed: getExecuted(),
error: error
}));
});
});
} else {
Array.from(executed.values()).reduce(function (result, step) {
var success = (0, _bind3.default)(step.success, (0, _extend3.default)({}, context, step), context.results);
return result.finally(function () {
return _bluebird.Promise.try(success);
});
}, _bluebird.Promise.resolve()).finally(function () {
logger.info('Dispatch succeeded.');
resolve(new WorkflowResult({
status: Workflow.States.SUCCESS,
executed: getExecuted(),
results: context.results
}));
});
}
});
steps.forEach(function (step, next, percent) {
if (!step.enabled) {
next();
}
var stepContext = (0, _extend3.default)({}, context, step),
execute = step.execute.apply.bind(step.execute, stepContext, args),
execLoop = function execLoop() {
executed.add(step);
logger.info('Executing ' + step.name + '.');
return _bluebird.Promise.try(execute).catch(function (err) {
return _bluebird.Promise.try((0, _bind3.default)(step.retry, stepContext, err)).then(execLoop);
});
};
_bluebird.Promise.try((0, _bind3.default)(step.init, stepContext)).then(execLoop).tap(function (result) {
return context.results[step.name] = result;
}).finally(function () {
return update(percent);
}).then(function () {
return next();
}, function (err) {
return next((0, _isUndefined3.default)(err) && 'Error occurred in ' + step.name + '.' || err);
});
}, function (error) {
execLoop = function execLoop() {
executed.add(step);
logger.info('Executing ' + step.name + '.');
return _bluebird.Promise.try(execute).catch(function (err) {
return _bluebird.Promise.try((0, _bind3.default)(step.retry, stepContext, err)).then(execLoop);
});
};
.then((maxId) => {
let promises = []
for (let i = 1; i <= maxId; i++) {
promises.push(this.findById('' + i))
}
return Promise.all(promises)
})
install(dir, plugin = null) {
if(plugin !== null) {
this.add(dir, plugin)
.then(function() {
return 0
})
} else {
if(config.plugins && Array.isArray(config.plugins)){
var ps = []
Array.prototype.forEach.call(config.plugins, (plugin) => {
ps.push(this.add(dir, plugin))
})
Promise.all(ps)
.then(function() {
return 0
})
} else {
console.log(clc.cyan('no plugin found'))
return 0
}
}
}
return __awaiter(this, void 0, void 0, function* () {
const output = yield util_1.exec("icns2png", ["-x", "-o", tempDir, path.join(this.buildResourcesDir, "icon.icns")]);
util_1.debug(output);
const imagePath = path.join(tempDir, "icon_256x256x32.png");
function resize(size) {
const sizeArg = `${ size }x${ size }`;
return util_1.exec("gm", ["convert", "-size", sizeArg, imagePath, "-resize", sizeArg, path.join(tempDir, `icon_${ size }x${ size }x32.png`)]);
}
const promises = [resize(24), resize(96)];
if (!(output.indexOf("is32") !== -1)) {
promises.push(resize(16));
}
if (!(output.indexOf("ih32") !== -1)) {
promises.push(resize(48));
}
if (!(output.toString().indexOf("icp6") !== -1)) {
promises.push(resize(64));
}
if (!(output.indexOf("it32") !== -1)) {
promises.push(resize(128));
}
yield bluebird_1.Promise.all(promises);
const appName = this.metadata.name;
function createMapping(size) {
return `${ tempDir }/icon_${ size }x${ size }x32.png=/usr/share/icons/hicolor/${ size }x${ size }/apps/${ appName }.png`;
}
return [createMapping("16"), createMapping("24"), createMapping("32"), createMapping("48"), createMapping("64"), createMapping("96"), createMapping("128"), createMapping("256"), createMapping("512")];
});
_checkReputation() {
const reputationCheckInterval = (this.userPlan || 'free') === 'free' ? 50 : 1000;
if (this.counter - this.lastReputationCheckedOn >= reputationCheckInterval) {
this.lastReputationCheckedOn = this.counter;
logger().debug('SendEmailService._checkReputation, working...');
return this._invokeGetUserData().then((response) => {
const userData = JSON.parse(response.Payload);
const reputationData = userData.reputationData;
this.reputation = reputationData.reputation;
logger().debug('SendEmailService._checkReputation user reputation:', reputationData);
if (reputationData.reputation < reputationData.minimumAllowedReputation) {
logger().error('SendEmailService._checkReputation, Bad Reputation detected', reputationData.reputation, 'stopping...');
return Promise.reject('Bad reputation');
}
return Promise.resolve({});
}).catch((error) => {
logger().warn('SendEmailService._checkReputation error occurred:', error);
if (error === 'Bad reputation') {
// return this.queue.purgeQueue().then(() => Promise.reject(error));
return Promise.reject(error);
}
// Being conservative since this should not break send emails proccess
return Promise.resolve({});
});
}
return Promise.resolve({});
}
export function sendRecordFiles(dispatch, records) {
//loop et send files
const allFiles = Object.keys(records).reduce((recordsFiles, tableId) => {
const tableRecords = records[tableId];
return Object.keys(tableRecords).reduce((tableFiles, recordId) => {
const record = tableRecords[recordId];
// console.log(record);
return tableFiles.concat(Object.keys(record).map(fieldId => {
const tmpName = record[fieldId];
//on n'a pas besoin de vérifier si le champ est d'un type particulier: le getfile retournera un file basé sur la value seulement, qui est un hash
const file = tmpName && getFileVal(tmpName);
if (!file) return null;
// console.log(file, tmpName);
return {
tmpName,
file,
fileName: file.name,
fieldId,
recordId,
tableId,
};
}).filter(r => r));
}, recordsFiles);
}, []);
// console.log(allFiles);
return Promise.mapSeries(allFiles, fileDef => {
return sendChunk(dispatch, fileDef);
});
}
return __awaiter(this, void 0, void 0, function* () {
let resourcesDir = appOutDir;
if (this.platform === metadata_1.Platform.OSX) {
resourcesDir = this.getOSXResourcesDir(appOutDir);
}
return yield bluebird_1.Promise.map((yield this.getExtraResources(arch, customBuildOptions)), it => fs_extra_p_1.copy(path.join(this.projectDir, it), path.join(resourcesDir, it)));
});
return __awaiter(this, void 0, void 0, function* () {
function addKeychain(args) {
if (keychain != null) {
args.push(keychain);
}
return args;
}
let result = exports.findIdentityRawResult;
if (result == null || keychain != null) {
// https://github.com/electron-userland/electron-builder/issues/481
// https://github.com/electron-userland/electron-builder/issues/535
result = bluebird_1.Promise.all([util_1.exec("security", addKeychain(["find-identity", "-v"])).then(it => it.trim().split("\n").filter(it => {
for (let prefix of appleCertificatePrefixes) {
if (it.indexOf(prefix) !== -1) {
return true;
}
}
return false;
})), util_1.exec("security", addKeychain(["find-identity", "-v", "-p", "codesigning"])).then(it => it.trim().split("\n"))]).then(it => {
const array = it[0].concat(it[1]).filter(it => !(it.indexOf("(Missing required extension)") !== -1) && !(it.indexOf("valid identities found") !== -1) && !(it.indexOf("iPhone ") !== -1) && !(it.indexOf("com.apple.idms.appleid.prd.") !== -1)).map(it => it.substring(it.indexOf(")") + 1).trim());
return Array.from(new Set(array));
});
if (keychain == null) {
exports.findIdentityRawResult = result;
}
}
return result;
});
function signFile(file, baseSignOptions) {
if (baseSignOptions != null && process.platform !== 'linux') {
const signOptions = Object.assign({}, baseSignOptions);
signOptions.path = file;
return sign(signOptions);
}
return _bluebird.Promise.resolve();
}
getExtraResources(isResources, arch, customBuildOptions) {
let patterns = this.devMetadata.build[isResources ? "extraResources" : "extraFiles"];
const platformSpecificPatterns = isResources ? customBuildOptions.extraResources : customBuildOptions.extraFiles;
if (platformSpecificPatterns != null) {
patterns = patterns == null ? platformSpecificPatterns : patterns.concat(platformSpecificPatterns);
}
return patterns == null ? bluebird_1.Promise.resolve(new Set()) : globby_1.globby(this.expandPatterns(patterns, arch), { cwd: this.projectDir });
}
unsubscribeRecipient() {
const { listId, recipientId } = this.emailMetadata;
if (this.shouldUnsubscribe()) {
const recipient = { status: this.newStatus };
recipient[`${this.newStatus}At`] = moment().unix();
return Recipient.update(omitEmpty(recipient), listId, recipientId);
}
return Promise.resolve({});
}
value: function shutdown() {
this._logger.info('shutdown....');
clearInterval(this._watcherId);
this._watcher = null;
this._receiver = null;
return _bluebird.Promise.resolve();
}
return __awaiter(this, void 0, void 0, function* () {
const zipPath = (yield bluebird_1.Promise.all([downloadElectron(createDownloadOpts(opts, platform, arch, electronVersion)), fs_extra_p_1.emptyDir(out)]))[0];
yield extract(zipPath, { dir: out });
if (platform === "darwin" || platform === "mas") {
yield require("./mac").createApp(opts, out, initializeApp);
} else {
yield initializeApp();
}
});
function doDownload(url, destination, redirectCount, options, callback) {
const ensureDirPromise = options.skipDirCreation ? bluebird_1.Promise.resolve() : fs_extra_p_1.ensureDir(path.dirname(destination));
const parsedUrl = url_1.parse(url);
// user-agent must be specified, otherwise some host can return 401 unauthorised
const request = https.request({
hostname: parsedUrl.hostname,
path: parsedUrl.path,
headers: {
"User-Agent": "electron-builder"
}
}, response => {
if (response.statusCode >= 400) {
callback(new Error(`Cannot download "${ url }", status ${ response.statusCode }: ${ response.statusMessage }`));
return;
}
const redirectUrl = response.headers.location;
if (redirectUrl != null) {
if (redirectCount < maxRedirects) {
doDownload(redirectUrl, destination, redirectCount++, options, callback);
} else {
callback(new Error("Too many redirects (> " + maxRedirects + ")"));
}
return;
}
const sha2Header = response.headers["X-Checksum-Sha2"];
if (sha2Header != null && options.sha2 != null) {
// todo why bintray doesn't send this header always
if (sha2Header == null) {
throw new Error("checksum is required, but server response doesn't contain X-Checksum-Sha2 header");
} else if (sha2Header !== options.sha2) {
throw new Error(`checksum mismatch: expected ${ options.sha2 } but got ${ sha2Header } (X-Checksum-Sha2 header)`);
}
}
ensureDirPromise.then(() => {
const fileOut = fs_extra_p_1.createWriteStream(destination);
if (options.sha2 == null) {
response.pipe(fileOut);
} else {
response.pipe(new DigestTransform(options.sha2)).pipe(fileOut);
}
fileOut.on("finish", callback);
}).catch(callback);
let ended = false;
response.on("end", () => {
ended = true;
});
response.on("close", () => {
if (!ended) {
callback(new Error("Request aborted"));
}
});
});
addTimeOutHandler(request, callback);
request.on("error", callback);
request.end();
}
beforeEach(() => {
const msearchMock = jest.fn().mockReturnValue(Promise.resolve([]));
searchArgs = {
searchRequests: [],
es: { msearch: msearchMock },
Promise,
serializeFetchParams: () => Promise.resolve([]),
};
});