const initTestApp = async ({ namespace }) => {
const adminApp = initAdminApp()
// await deleteAllUsers(adminApp)
const testUser = await createTestAnonymousUser(adminApp)
const serviceAccount = getServiceAccount()
const app = admin.initializeApp(
{
credential: admin.credential.cert(serviceAccount),
databaseAuthVariableOverride: {
uid: testUser.uid
},
databaseURL: `https://${process.env.FIREBASE_PROJECT_ID}.firebaseio.com`,
messagingSenderId: `${process.env.FIREBASE_MESSAGING_SENDER_ID}`,
storageBucket: `${process.env.FIREBASE_PROJECT_ID}.appspot.com`
},
namespace
)
const { database } = app
app.database = (...args) => {
const result = database.call(app, ...args)
result.namespace = namespace
return result
}
app.namespace = namespace
app.testUser = testUser
app.adminApp = adminApp
return app
}
beforeAll(() => {
this.firebase = firebase.initializeApp({
credential: firebase.credential.cert(process.env.FIREBASE_SERVICE_ACCOUNT),
databaseURL: process.env.FIREBASE_DATABASE_URL,
})
this.store = new FirebaseStore({
database: this.firebase.database(),
})
})
function initialize(config) {
if (firebase.apps.length > 0) {
// No need to inititalize again
return;
}
// Initialize for the first time
firebase.initializeApp({
credential: firebase.credential.cert(config.serviceAccount),
databaseURL: 'https://' + config.serviceAccount.project_id + '.firebaseio.com'
});
}
constructor(config, arrivalStats, stats) {
this.arrivalStats = arrivalStats;
this.stats = stats;
try {
admin.initializeApp({
credential: admin.credential.cert(config.serviceAccount),
databaseURL: config.databaseURL
});
} catch (err) {}
this.type = "fcm";
this.notify_foreground = (config.notify_foreground === 0) ? 0 : 1;
}
function ControllerPush() {
this.timeInterval = 60*1000; //1min
this.url = config.serviceServer.url;
try {
if (twFirebaseAdmin == undefined) {
var twServiceAccount = require("../config/admob-app-id-6159460161-firebase-adminsdk-r2shn-9e77fbe119.json");
twFirebaseAdmin = admin.initializeApp({
credential: admin.credential.cert(twServiceAccount),
}, 'todayWeather');
}
if (taFirebaseAdmin == undefined) {
var taServiceAccount = require("../config/todayair-74958-firebase-adminsdk-2n8hn-68ad361049.json");
taFirebaseAdmin = admin.initializeApp({
credential: admin.credential.cert(taServiceAccount),
}, 'todayAir');
}
}
catch (err) {
log.error(err);
}
}
constructor() {
if (firebaseApp == null) {
console.log("Initialize connection to Firebase");
let learnPortalCredential = firebase.credential.cert(serviceAccount);
firebaseApp = firebase.initializeApp({
credential: learnPortalCredential,
databaseURL: process.env.FIREBASE_DB_URL
}, "Dashboard");
}
if (firebaseApp != null && firebaseDb == null) {
firebaseDb = firebase.database(firebaseApp);
}
}
module.exports = function postSubscribe(params, user) {
const { fcmToken } = params;
if (fcmToken) {
const { config } = this;
const { firebase: { adminCert, messaging: { topic: { eventPrefix } } } } = config;
const { id } = params;
const topic = `${eventPrefix}${id}`;
if (!admin.apps.length) {
admin.initializeApp({
credential: admin.credential.cert(adminCert),
});
}
return admin
.messaging()
.unsubscribeFromTopic(fcmToken, topic)
.then(() => this.log.info(`${user.id} successfully unsubscribed from topic: ${topic}`))
.catch(error => this.log.warn(`Error unsubscribing from topic: ${topic}`, error));
}
return null;
};
/********************************************************************************************
*
* Config files are json files that contain the firebase project id/name "name" property
*
* {
* "name": "production-project-id",
* "credentials": "production-rw.json"
* }
*
* Service account credentials (json files form google) are in a credentials subfolder
* named by the "credentials" property (or named with project name)
*
*********************************************************************************************/
/**
* Get server-side initialization info & credentials for twt firebase project
* @param {String} project project id, project alias or defaults to 'default'
* @param {String} user twt userId or 'backend' or 'admin' or defaults to 'backend'
* @param {String} [configPath] twt-config directory or default to home directory + 'twt-config'
* @returns {{name: String, initOptions: Object, databaseURL: string}}
*/
function getFirebaseConfig (project, user, configPath) {
if (!project) {
project = process.env.TWT_PROJECT || 'default';
}
let twtProject = {
name: project
};
let configFilePath = path.join(configPath, `${project}.json`);
if (fs.existsSync(configFilePath)) {
twtProject = require(configFilePath);
if (twtProject.name !== project) {
twtProject.alias = project;
}
} else {
return null;
}
twtProject.databaseURL = `https://${twtProject.name}.firebaseio.com`;
twtProject.credentialsPath = path.join(configPath, 'credentials', twtProject.credentials || twtProject.name + '.json');
twtProject.serviceAccount = require(twtProject.credentialsPath);
twtProject.initOptions = {
credential: admin.credential.cert(twtProject.serviceAccount),
databaseURL: twtProject.databaseURL
};
if (!user || user !== 'admin') {
twtProject.uid = user || 'backend';
twtProject.initOptions.databaseAuthVariableOverride = {uid: twtProject.uid};
if (twtProject.uid === 'backend') {
twtProject.initOptions.databaseAuthVariableOverride.isBackendProcess = true;
}
}
return twtProject;
}
const initializeAdminApp = ({ configs, namespace, prefix, testUser }) => {
let config
if (namespace) {
config = prop(namespace, configs) || prop('default', configs)
} else {
config = prop('default', configs)
}
if (!config) {
throw new Error(`No firebase config found for ${namespace} and no default config provided`)
}
const { serviceAccount, ...rest } = config
let appConfig = {
credential: admin.credential.cert(serviceAccount),
...rest
}
if (testUser) {
appConfig = {
...appConfig,
databaseAuthVariableOverride: {
uid: testUser.uid
}
}
}
const app = admin.initializeApp(
appConfig,
`${prefix ? prefix + ':' : ''}${namespace || '[DEFAULT]'}`
)
const { database } = app
app.database = (...args) => {
const db = database.call(app, ...args)
db.namespace = namespace
return db
}
app.namespace = namespace
return app
}
proxy.setAcmeChallenge = autocert.setChallenge
proxy.isAcmeHttpChallenge = pathname => {
return /^\/\.well-known\/acme-challenge/.test(pathname)
}
proxy.apps.acme = {
ports: {
80: true
}
}
// storage intergration
var storage = Firebase.initializeApp({
databaseURL: `https://${env.firebaseAppId}.firebaseio.com`,
credential: Firebase.credential.cert(env.googleServiceAccount)
})
var toRef = path => storage.database().ref('proxy/' + path)
var apps = new Collection({
storage: toRef('apps'),
items: proxy.apps
})
apps.on('change', proxy.onappchange)
new Collection({
storage: toRef('names'),
items: proxy.names,
parseKey: key => key.replace(/%/g, '.')
})
var firebase = require("firebase-admin");
firebase.initializeApp({
credential: firebase.credential.cert("./config/firebaseapi/dressme-c8474-firebase-adminsdk-xxwt8-eb8ec14e67.json"),
databaseURL: "https://dressme-c8474.firebaseio.com"
});
module.exports = firebase;
#!/usr/bin/env node
// Using the firebase-admin approach where database security rules do not apply.
// Here you are authenticating with a private key. The key JSON file is available via
// the Firebase web UI: project settings > service accounts > generate new private key.
var admin = require("firebase-admin");
const serviceAccountKeyFile = process.env.FIREBASE_SERVICE_ACCOUNT_KEY_FILE;
if (!serviceAccountKeyFile) {
console.error('Set FIREBASE_SERVICE_ACCOUNT_KEY_FILE to the path to your credentials file.');
process.exit();
}
admin.initializeApp({
credential: admin.credential.cert(serviceAccountKeyFile),
databaseURL: "https://projectionist-d5fef.firebaseio.com"
});
var firestore = admin.firestore();
var storage = admin.storage();
var repl = require("repl");
var replServer = repl.start({
prompt: "firebase> ",
});
replServer.context.admin = admin;
replServer.context.firestore = firestore;
replServer.context.storage = storage;
import firebase from 'firebase-admin'
import { AuthenticationError } from 'apollo-server-koa'
const {
FIREBASE_PROTECTED_ID,
FIREBASE_CLIENT_EMAIL,
FIREBASE_PRIVATE_KEY,
} = process.env
firebase.initializeApp({
credential: firebase.credential.cert({
projectId: FIREBASE_PROTECTED_ID,
clientEmail: FIREBASE_CLIENT_EMAIL,
privateKey: FIREBASE_PRIVATE_KEY.replace(/\\n/g, '\n'),
}),
})
export default async (token) => {
if (!token) {
return {}
}
try {
return await firebase.auth().verifyIdToken(token)
} catch (e) {
throw new AuthenticationError(e.message)
}
}
function FCM(accountKey, proxy_url=null) {
if(!proxy_url) {
proxy_url = process.env.http_proxy || null;
}
if(!accountKey) {
throw Error('You must provide the APIKEY for your firebase application.');
}
else if(typeof accountKey == 'string') { //API KEY PASSED string, legacy use
this.serverKey = accountKey;
this.fcmOptions = {
host: 'fcm.googleapis.com',
port: 443,
path: '/fcm/send',
method: 'POST',
headers: {}
};
this.send = function (payload, CB) {
var self = this;
if (!CB) {
throw Error('you must provide a callback function(err,result)'); //just in case
}
else {
var operation = retry.operation();
var mpayload = JSON.stringify(payload);
var mFcmOptions = JSON.parse(JSON.stringify(self.fcmOptions)) //copying the fcmOptions object to avoid problems in parallel calls
if(proxy_url) {
// HTTP/HTTPS proxy to connect to
var proxy = proxy_url;
var agent = new HttpsProxyAgent(proxy);
mFcmOptions.agent = agent;
}
operation.attempt(function (currentAttempt) {
var headers = {
'Host': mFcmOptions.host,
'Authorization': 'key=' + self.serverKey,
'Content-Type': 'application/json'
//'Content-Length': mpayload.length //removed this line for chunk-encoded transfer compatibility (UTF-8 and all non-ANSI codification)
};
mFcmOptions.headers = headers;
if (self.keepAlive) headers.Connection = 'keep-alive';
var request = https.request(mFcmOptions, function (res) {
var data = '';
if (res.statusCode == 503) {
// If the server is temporary unavailable, the FCM spec requires that we implement exponential backoff
// and respect any Retry-After header
if (res.headers['retry-after']) {
var retrySeconds = res.headers['retry-after'] * 1; // force number
if (isNaN(retrySeconds)) {
// The Retry-After header is a HTTP-date, try to parse it
retrySeconds = new Date(res.headers['retry-after']).getTime() - new Date().getTime();
}
if (!isNaN(retrySeconds) && retrySeconds > 0) {
operation._timeouts['minTimeout'] = retrySeconds;
}
}
if (!operation.retry('TemporaryUnavailable')) {
CB(operation.mainError(), null);
}
// Ignore all subsequent events for this request
return;
}
function respond() {
var error = null, id = null;
//Handle the various responses
if (data.indexOf('\"multicast_id\":') > -1)//multicast_id success
{
var anyFail = ((JSON.parse(data)).failure > 0);
if (anyFail) {
error = data.substring(0).trim();
}
var anySuccess = ((JSON.parse(data)).success > 0);
if (anySuccess) {
id = data.substring(0).trim();
}
} else if (data.indexOf('\"message_id\":') > -1) { //topic messages success
id = data;
} else if (data.indexOf('\"error\":') > -1) { //topic messages error
error = data;
} else if (data.indexOf('TopicsMessageRateExceeded') > -1) {
error = 'TopicsMessageRateExceededError'
} else if (data.indexOf('Unauthorized') > -1) {
error = 'NotAuthorizedError'
} else {
error = 'InvalidServerResponse';
}
// Only retry if error is QuotaExceeded or DeviceQuotaExceeded
if (operation.retry(currentAttempt <= 3 && ['QuotaExceeded', 'DeviceQuotaExceeded', 'InvalidServerResponse'].indexOf(error) >= 0 ? error : null)) {
return;
}
// Success, return message id (without id=)
CB(error, id);
}
res.on('data', function (chunk) {
data += chunk;
});
res.on('end', respond);
res.on('close', respond);
});
request.on('error', function (error) {
CB(error, null);
});
request.end(mpayload);
});
}
}
// Subscribe devices to topic
// If topic does not exist, a new one is created
this.subscribeToTopic = (deviceTokens, topicName, CB) => {
const options = TopicOptions('iid.googleapis.com', '/iid/v1:batchAdd', 'POST', this.serverKey.slice(0));
const subscriptionData = TopicData(topicName, deviceTokens);
TopicRequest(options, subscriptionData, (err, res) => {
CB(err, res);
});
}
// Unsubscribe device to topic
this.unsubscribeToTopic = (deviceTokens, topicName, CB) => {
const options = TopicOptions('iid.googleapis.com', '/iid/v1:batchRemove', 'POST', this.serverKey.slice(0));
const unsubscriptionData = TopicData(topicName, deviceTokens);
TopicRequest(options, unsubscriptionData, (err, res) => {
CB(err, res);
});
}
}
else{ //accountkey object passed, new SDK 'de-promisefy' use
firebaseadmin.initializeApp({
credential: firebaseadmin.credential.cert(accountKey)
});
this.send = function(payload, _callback){
if (!_callback) {
throw Error('You must provide a callback function(err,result)')
}
else{
if(!payload) _callback(new Error('You must provide a payload object'))
else{
if(payload.to) {
if (typeof payload.to == 'string') {
var to = payload.to
delete payload.to
if (to.startsWith('/topics/')) {
var topic = to.slice(8)//anything after '/topics/'
firebaseadmin.messaging().sendToTopic(topic, payload)
.then(function(response){_callback(null, response)})
.catch(function (err) {_callback(err)})
}
else{
firebaseadmin.messaging().sendToDevice(to,payload)
.then(function (response) {_callback(null,response)})
.catch(function (error) {_callback(error)})
}
}
else{
var err = new Error('Invalid "to" field in payload');
_callback(err)
}
}
else if(payload.registration_ids){
var regIds = payload.registration_ids;
delete payload.registration_ids;
if(regIds instanceof Array && typeof regIds[0] == 'string')
{
firebaseadmin.messaging().sendToDevice(regIds, payload)
.then(function (response) {_callback(null,response)})
.catch(function (error) {_callback(error)})
}
else{
var err = new Error('Invalid "registration_ids" field in payload');
_callback(err)
}
}
else{
var err = new Error('Invalid payload object');
_callback(err)
}
}
}
}
}
}
const admin = require('firebase-admin');
const firebaseConfig = require('./env.json').firebaseConfig;
const secret = firebaseConfig.secret;
admin.initializeApp({
databaseURL: firebaseConfig.databaseURL,
credential: admin.credential.cert(firebaseConfig.serviceAccount)
});
const ref = admin.database().ref('firebasePaginator');
const collectionRef = ref.child('collection');
const smallCollectionRef = ref.child('small-collection');
const emptyCollectionRef = ref.child('empty-collection');
const FirebasePaginator = require('./firebase-paginator');
describe('Firebase Paginator', () => {
let paginator;
beforeAll(done => {
ref.remove().then(done);
});
beforeAll(done => {
populateCollection(100, collectionRef).then(done);
});
beforeAll(done => {
populateCollection(3, smallCollectionRef).then(done);
});
const express = require('express')
const bodyParser = require('body-parser')
const session = require('express-session')
const FileStore = require('session-file-store')(session)
const next = require('next')
const admin = require('firebase-admin')
const dev = process.env.NODE_ENV !== 'production'
const app = next({ dev })
const handle = app.getRequestHandler()
const firebase = admin.initializeApp({
credential: admin.credential.cert(require('./credentials/server')),
databaseURL: '' // TODO database URL goes here
}, 'server')
app.prepare()
.then(() => {
const server = express()
server.use(bodyParser.json())
server.use(session({
secret: 'geheimnis',
saveUninitialized: true,
store: new FileStore({path: '/tmp/sessions', secret: 'geheimnis'}),
resave: false,
rolling: true,
httpOnly: true,
cookie: { maxAge: 604800000 } // week
}))
const admin = require('firebase-admin');
const serviceAccount = require('./serviceAccountKey.json');
const app = admin.initializeApp({
credential: admin.credential.cert(serviceAccount),
databaseURL: "https://marctalk-623a0.firebaseio.com",
databaseAuthVariableOverride: {
uid: "marcwang"
}
});
const db = app.database();
// const public_ref = db.ref("public_resource");
// public_ref.once("value", (snapshot) => {
// console.log(snapshot.val());
// });
const ref = db.ref("public_resource/school/class");
// saving data with set
const classmates = [
{ name: 'Marc', id: '1001' },
{ name: 'David', id: '1002' },
{ name: 'Sam', id: '1003' },
{ name: 'Andy', id: '1004' }
];
classmates.map(c => {
const users_ref = ref.child(c.id);
users_ref.set({
create_time: Date.now(),
name: c.name,
typeof config[key] === 'object'
? JSON.stringify(config[key])
: config[key];
});
}
dotenv.config({ path: `.env.${process.env.NODE_ENV}` });
dotenv.config({ path: '.env.local' });
dotenv.config({ path: '.env' });
// Configure Firebase Admin SDK
// https://firebase.google.com/docs/admin/setup
if (!firebase.apps.length) {
firebase.initializeApp({
credential: firebase.credential.cert(
JSON.parse(process.env.GCP_SERVICE_KEY),
),
});
}
if (process.env.NODE_ENV === 'production') {
// Server environment
exports.app = functions
.runWith({ memory: '2GB' })
.https.onRequest(require('./app').default);
} else {
// Local/dev environment
const app = express();
const db = require('./db').default;
app.use(require('./app').default);
module.exports.default = app;
import { FunctionTree } from 'function-tree';
import { Devtools } from 'function-tree/devtools';
import firebase from 'firebase-admin';
import { Provider as FirebaseProvider } from './providers/Firebase-admin';
import { Provider as CalendarProvider } from './providers/Calendar';
import { Provider as MailProvider } from './providers/Mail';
const config = require(`../configs/service-${process.env.SKK_ENV}.json`);
let devtools = null;
firebase.initializeApp({
credential: firebase.credential.cert(config.firebaseServiceAccount),
databaseURL: config.databaseURL,
storageBucket: config.storageBucketUrl,
});
if (process.env.NODE_ENV !== 'production') {
devtools = new Devtools({
host: 'localhost:9898',
});
}
const ft = new FunctionTree({
firebase: FirebaseProvider({}, firebase),
mail: MailProvider({ APIKey: process.env.sendgrid }),
calendar: CalendarProvider({
serviceAccount: config.calendarServiceAccount,
}),
});
'use strict'
var fs = require('fs');
var path = require('path');
var fbVars = require('../config/firebase.admin');
var admin = require("firebase-admin");
// Initialize Firebase
admin.initializeApp({
credential: admin.credential.cert(fbVars),
databaseURL: "https://ah-nuts.firebaseio.com"
});
var db = admin.database();
var ref = db.ref('sales');
ref.once('value', function(snapshot) {
console.log(snapshot.val());
});
#!/usr/bin/env node
require('dotenv').config({ silent: true });
var admin = require("firebase-admin");
admin.initializeApp({
credential: admin.credential.cert({
projectId: process.env.FIREBASE_PROJECT_ID,
clientEmail: process.env.FIREBASE_CLIENT_EMAIL,
privateKey: process.env.FIREBASE_PRIVATE_KEY,
}),
databaseURL: process.env.FIREBASE_DATABASE_URL
});
var db = admin.database();
const versionsRef = db.ref('versions');
const settingsRef = db.ref('settings');
const worklogsRef = db.ref('worklogs');
const timestamp = new Date().getTime();
const exec = require('sync-exec');
const cmd = './node_modules/.bin/jira-worklog'
+ ` -H ${process.env.JIRA_HOST}`
+ ` -u ${process.env.JIRA_USERNAME}`
+ ` -p ${process.env.JIRA_PASSWORD}`;
console.log('Loading data from jira-worklog...');
const result = exec(cmd);
const data = JSON.parse(result.stdout);
console.log('Processing firebase...');
const express = require('express');
const router = express.Router();
const json2csv = require('json2csv').parse;
const firebase = require("firebase-admin");
const serviceAccount = require('./firebase.json');
// const fs = require('fs');
const moment = require('moment');
const geodistance = require('./geodistance');
const nodemailer = require('nodemailer');
const nmmgt = require('nodemailer-mailgun-transport');
const mailgun = require('./mailgun.json');
const dbURL = "https://ss-smtracking.firebaseio.com";
firebase.initializeApp({
credential: firebase.credential.cert(serviceAccount),
databaseURL: dbURL
});
const fB = firebase.database().refFromURL(dbURL);
exports.getCompanyOfVehicle = (vehicle_id, done) => {
fB.child('CONTROL/VEHICLES').orderByChild('id').equalTo(vehicle_id).on('value', snap => {
done(snap.val());
})
};
router.post('/savetrail', (req, res) => {
let data = req.body;
exports.getCompanyOfVehicle(data.vehicle_id, async cb => {
if (!cb) return res.status(404).send('Vehicle not found.');
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp({
credential: admin.credential.applicationDefault()
});
// // Create and Deploy Your First Cloud Functions
// // https://firebase.google.com/docs/functions/write-firebase-functions
//
// exports.helloWorld = functions.https.onRequest((request, response) => {
// response.send("Hello from Firebase!");
// });
exports.onCarChangedLocation = functions.firestore
.document('/cars/{carId}')
.onUpdate((change, context) => {
// Get an object representing the document
const newValue = change.after.data();
// ...or the previous value before this update
const previousValue = change.before.data();
// access a particular field as you would any JS property
const parked_at_now = newValue.parked_at;
const parked_at_before = previousValue.parked_at;
if (!parked_at_now || !parked_at_now.location) {
console.log('No new parking location');
return null;
}