Develop Reference

Why is my cloud function returning the last return value instead of an earlier one?

I have a button on the client side that is helping me test a simplified version of a backend function. For some reason, the client side (Logcat in Android Studio) is returning test button isUsernameAvailable: Success. result.data = 2000. When I look at the Firebase console, I see that the code reached _isUsernameAvailable REACHED THEN. However, I don't understand why the client received a 2000 instead of a 5. If it reached the aforementioned section, the line after that reads return 5. Why didn't my client receive a 5?
Client code:
testbutton.setOnClickListener() {
functions = Firebase.functions
var data = hashMapOf<String, Any>()
data["username"] = "ThisUsernameDoesntExist"
functions.getHttpsCallable("isUsernameAvailable")
.call(data)
.addOnSuccessListener {result ->
Log.e(tag, "test button isUsernameAvailable: Success. result.data = " + result.data.toString())
}
.addOnFailureListener {exception ->
Log.e(tag, "test button failure exception: $exception")
}
}
Cloud Function code:
//Check if username is available (callable from client)
exports.isUsernameAvailable = functions.https.onCall(async(data, context) => {
const username = data.username
await admin.firestore().collection('users').where('username', '==', username).limit(1).get()
.then(result => {
console.log('_isUsernameAvailable REACHED THEN ')
return 5
})
.catch(error => {
console.log('_isUsernameAvailable REACHED CATCH ')
return 6
})
return 2000
});

This answer partly explained what's happening on your code. To apply on your case, return 5 is just returning from the Firestore callback function and it does not cause your main function process to end.
A solution is to create a variable to assign the value whenever an event is met instead of returning it:
exports.isUsernameAvailable = functions.https.onCall(async(data, context) => {
const username = data.username
var returnCode = 0
await admin.firestore().collection('users').where('username', '==', username).limit(1).get()
.then(result => {
console.log('_isUsernameAvailable REACHED THEN ')
returnCode = 5
})
.catch(error => {
console.log('_isUsernameAvailable REACHED CATCH ')
returnCode = 6
})
if (returnCode != 2000){
return returnCode
}
return 2000
});

Upload APK and set track for publishing

I am trying to set a new track and upload APK for publishing using nodejs... But no APK is uploaded nor is there a track set.
But the results from the validation and all the other steps are exactly as I expect(according to API). The script succeeds, yet nothing changes in the developer console... So is there a magic guru out there that may see my issue?
NOTE 1: I did publish my app manually because the android-publisher is only for updating apps that have been published before
NOTE 2: This worked before(a long time ago), and has stopped working for a while, I finally got around to updating everything
My code:
var google = require('googleapis').google;
var Promise = require('bluebird');
var _ = require('lodash');
var settings = require('./config/settings.json');
// Enable API access into the Developer Console: https://play.google.com/apps/publish/?account=7639196906174529268#ApiAccessPlace
// Create a service account
// Download the JSON and save it here
// Make sure the email of the JSON is added to the apps for release manager role:
// https://play.google.com/apps/publish/?account=7639196906174529268#AdminPlace
var key = require('./config/google-play-user.json');
// editing "scope" allowed for OAuth2
var scopes = [
'https://www.googleapis.com/auth/androidpublisher'
];
var OAuth2 = google.auth.OAuth2;
var oauth2Client = new OAuth2();
var jwtClient = new google.auth.JWT(key.client_email, null, key.private_key, scopes, null);
var play = google.androidpublisher({
version: 'v3',
auth: oauth2Client,
params: {
// default options
// this is the package name for your initial app you've already set up on the Play Store
packageName: settings.app.id
}
});
google.options({auth: oauth2Client});
// Start with a new edit.
startEdit().then(function(data) {
// Load our APK(in this case a Cordova APK).
var standardAPK = require('fs').readFileSync('./platforms/android/build/outputs/apk/android-release.apk');
// Stage the upload (doesn't actually upload anything).
return upload({
edit: data.edit,
apk: standardAPK,
key: 'standardApk'
});
}).then(function(data) {
// Set our track.
return setTrack(data);
}).then(function(data) {
// Validate our changes.
return validateToPlayStore(data);
}).then(function(data) {
console.log('Successful uploaded APK files:', data);
}).catch(function(err) {
console.log(err);
process.exit(1);
});
/**
* Sets our authorization token and begins an edit transaction.
*/
function startEdit() {
return new Promise(function(resolve, reject) {
jwtClient.authorize(function(err, tokens) {
if (err) {
console.log(err);
process.exit(1);
return;
}
// Set the credentials before we doing anything.
oauth2Client.setCredentials(tokens);
play.edits.insert({
packageName: settings.app.id
}, function(err, edit) {
if (err || !edit) { reject(err); }
resolve({
edit: edit.data
});
});
});
});
}
/**
* Stages an upload of the APK (but doesn't actually upload anything)
*/
function upload(data) {
var edit = data.edit;
var apk = data.apk;
var key = data.key;
return new Promise(function(resolve, reject) {
play.edits.apks.upload({
editId: edit.id,
packageName: settings.app.id,
media: {
mimeType: 'application/vnd.android.package-archive',
body: apk
}
}, function(err, res) {
if (err || !res) { reject(err); }
// Pass any data we care about to the next function call.
var obj = {};
obj[key] = res.data;
resolve(_.omit(_.extend(data, obj), 'apk'));
});
});
}
/**
* Sets our track (beta, production, etc.)
*/
function setTrack(data) {
var edit = data.edit;
var track = 'production';
return new Promise(function(resolve, reject) {
play.edits.tracks.update({
editId: edit.id,
track: track,
packageName: settings.app.id
}, function(err, res) {
if (err || !res) { reject(err); }
resolve(_.extend(data, {setTrackResults: res.data}));
});
});
}
/**
* Validates our edit transaction and makes our changes live.
*/
function validateToPlayStore(data) {
return new Promise(function(resolve, reject) {
// play.edits.commit({ // Commit will set the change LIVE
play.edits.validate({ // Validate will only validate it, not set it LIVE.
editId: data.edit.id,
packageName: settings.app.id
}, function(err, res) {
if (err || !res) { reject(err); }
resolve(_.extend(data, {validateToPlayStoreResults: res.data}));
});
});
}
Originally from http://frontendcollisionblog.com/javascript/2015/12/26/using-nodejs-to-upload-app-to-google-play.html when it still worked

You can use apkup to upload APKs to Google Play. apkup is basically a friendly wrapper/CLI for the googleapis package.
CLI example:
npx apkup \
--key ./config/google-play-user.json \
--release-notes "en-US=lorem ipsum dolor" \
--apk ./platforms/android/build/outputs/apk/android-release.apk
Node.js example:
const { Apkup } = require('apkup')
const key = require('./config/google-play-user.json')
const apkup = new Apkup(key)
apkup
.upload('./platforms/android/build/outputs/apk/android-release.apk', {
releaseNotes: [
{
language: 'en-US',
text: 'Minor bug fixes...'
}
]
})
.then(data => {
console.log(` > ${data.packageName} version ${data.versionCode} is up!`)
})

Authentication with Passport Session on Android

I have a web app currently running with NodeJS and Express, where I authenticate the users using Passport sessions, and it works perfectly. Here is the overview of what I do:
app.use(session({
secret : 'hidden of course :)',
resave: false,
saveUninitialized: true
}));
app.use(passport.initialize());
app.use(passport.session());
/****** Passport functions ******/
passport.serializeUser(function (user, done) {
done(null, user.idUser);
});
passport.deserializeUser(function (id, done) {
db.user.findOne( { where : { idUser : id } }).then(function (user, err) {
done(null, user);
});
});
//Facebook
passport.use(new FacebookStrategy({
//Information stored on config/auth.js
clientID: *******,
clientSecret: ******,
callbackURL: *******,
profileFields: ['id', 'emails', 'displayName', 'name', 'gender', 'picture.type(large)']
}, function (accessToken, refreshToken, profile, done) {
//Using next tick to take advantage of async properties
process.nextTick(function () {
db.user.findOne( { where : { idUser : profile.id } }).then(function (user, err) {
if(err) {
return done(err);
}
if(user) {
return done(null, user);
} else {
// Check whether the email is undefined or valid
var emailTemp = '';
if(profile.emails && profile.emails[0] && profile.emails[0].value) {
emailTemp = profile.emails[0].value;
} else {
emailTemp = '';
}
var picture = '';
if(profile.photos && profile.photos[0] && profile.photos[0].value) {
picture = profile.photos[0].value;
} else {
picture = '/img/profile.png';
}
var sexFb = '';
if(profile.gender) {
sexFb = profile.gender;
} else {
sexFb = '';
}
// Create the user
db.user.create({
idUser : profile.id,
token : accessToken,
picture : picture,
nameUser : profile.displayName,
email : emailTemp,
sex : sexFb
}).then(function () {
db.user.findOne( { where : { idUser : profile.id } }).then(function (user, err) {
if(user) {
return done(null, user);
} else {
return done(err);
}
});
});
}
});
});
}));
app.use(express.static(__dirname + '/public/'));
/* FACEBOOK STRATEGY */
// Redirect the user to Facebook for authentication. When complete,
// Facebook will redirect the user back to the application at
// /auth/facebook/callback//
app.get('/auth/facebook', passport.authenticate('facebook', { scope : ['email']}));
/* FACEBOOK STRATEGY */
// Facebook will redirect the user to this URL after approval. Finish the
// authentication process by attempting to obtain an access token. If
// access was granted, the user will be logged in. Otherwise,
// authentication has failed.
app.get('/auth/facebook/callback',
passport.authenticate('facebook', { failureRedirect: '/' }),
function (req, res) {
// Successful authentication, redirect home.
res.redirect('../../app.html');
});
Now, I'm building our Android App and I need to authenticate our users, preferably using the backend I already built for the web version. I was checking some questions on SO like this one and I understood a lot of what I would have to do.
Currently my clients stay logged in through the cookie that Express-session handles, saving the user's id on the req.user, so that I can run queries like on this example:
app.put('/profile', function (req, res) {
//Updates the profile information of the user
db.user.update({
nameUser : req.body.nameUser
}, {
where : {
idUser : req.user.idUser
}
}).then(function (user) {
res.json({ yes : "yes" });
});
});
So my questions:
Can I authenticate my users using the same strategy as the one I currently have? If not, what would I have to change to be able to authenticate my users on Android?
Once they are authenticated, how can I set the req.user from Android (through HTTP request or whatever mean) to correctly perform the tasks on the backend (since all my requests are based on req.user)? I assume Android doesn't keep cookies like browsers do, so how would Passport Sessions know which user is calling the API?
I currently use Retrofit2 on my Android app to interact with the API, is it able to perform the actions necessary for this task?
Sorry for the long post, added a good chunk of code just to be on the safe side, if you guys have any questions or need any explanation please let me know!

Android HTTP errors when using POST with Appcelerator

I'm using Appcelerator to build an app for both iOS and Android.
Part of the app requires HTTP POSTs to an API.
This works great on iOS, but fails on Android, giving me this error in the process...
[ERROR] : TiHttpClient: org.apache.http.client.HttpResponseException: Not Acceptable
I understand there may be a few differences in how Android handles these calls, but I'm not exactly sure what I need to change in order for them to work.
Here is one of the calls I'm making.
Any pointers on what i could be doing wrong?
function doRegister() {
// check to see if we already have a username saved
if (!Ti.App.Properties.getString('userEmail')) {
var userEmailfromBox = Ti.App.Properties.getString('userEmailfromBox');
var HashedEmail = Ti.Utils.sha256(userEmailfromBox);
var registerData = {
"account": {
"name": userEmailfromBox,
"mail": userEmailfromBox,
"pass": HashedEmail,
"field_user_type": {
"und": "xxxxx"
}
}
};
var registration = Ti.Network.createHTTPClient({
onload: function() {
// handle the response
Ti.API.info(this.responseText);
// need to save this email so we don't keep registering the user
Ti.App.Properties.setString('userEmail', userEmailfromBox);
// then we need to load the next step
doLogin();
},
onerror : function(e) {
Ti.API.info('Registering: ' + e.error);
//alert('error');
// then we need to load the next step
//doLogin();
}
});
registration.open('POST', 'https://www.myurlredacted.com');
// change the loading message
//loaderWheel.message = 'Creating User';
loaderWheel.message = 'Uploading Your Photos';
// show the indicator
loaderWheel.show();
// set the header for the correct JSON format
registration.setRequestHeader("Content-Type", "application/json; charset=utf-8");
// send the data to the server
registration.send(JSON.stringify(registerData));
} else {
// user is already registered, so skip them onto the next step
Ti.API.info('user already registered');
// then we need to load the next step
doLogin();
}
}

I just ran the following code based on yours:
var url = "http://requestb.in/1iuahxb1";
var registerData = {
"account": {
"name": 'userEmailfromBox',
"mail": 'userEmailfromBox',
"pass": 'HashedEmail',
"field_user_type": {
"und": "xxxxx"
}
}
};
var registration = Ti.Network.createHTTPClient({
onload: function () {
// handle the response
Ti.API.info(this.responseText);
},
onerror: function (e) {
Ti.API.info('Registering: ' + e.error);
}
});
registration.open('POST', url);
// set the header for the correct JSON format
registration.setRequestHeader("Content-Type", "application/json; charset=utf-8");
// send the data to the server
registration.send(JSON.stringify(registerData));
It runs without errors and the requestb.in recieves the post:
http://requestb.in/1iuahxb1?inspect

How do we store facebook user's details in parse?

I am using login with facebook utility of parse in my android application. Login with facebook utility works fine. it inserts only "userName" and "authData" column of "User" table.
I am getting name and email of facebook user using graph API of facebook.
Question -
How do we store "fullName" and "email" of facebook user into parse?
Thanks in advance!

I was able to write user Facebook details in CloudCode by doing the following:
Parse.Cloud.beforeSave(Parse.User, function (request, response) {
// Use Master Key
Parse.Cloud.useMasterKey();
// Pull User Object
var User = request.object;
// User Check
if (!User) {
// Not allowed
response.error();
return;
}
// For some reason, pulling authData fails. A try catch helps the TypeError that may happen
try {
var authData = User.get('authData');
var access_token = authData.facebook.access_token;
} catch(e) {
var access_token = null;
}
Parse.Cloud.httpRequest({
url:'https://graph.facebook.com/v2.1/me?fields=picture.height(50).width(50),email,first_name,last_name,friends.limit(5000),name,gender&access_token='+access_token,
success:function (httpResponse) {
// Success
var facebookIds = [];
try {
var facebookFriends = httpResponse.data.friends.data;
} catch (e) {
var facebookFriends = [];
}
var promise = _.each(facebookFriends, function(facebookFriend) {
facebookIds.push(facebookFriend.id);
});
Parse.Promise.when([promise]).then(function () {
if (request.object.existed() == false) {
User.set("displayName", httpResponse.data.name);
}
// Updating user object
User.set("facebookFriends", facebookIds);
User.set("fbEmail", httpResponse.data.email);
User.set("profileThumb", httpResponse.data.picture.data.url);
User.set("facebookId", httpResponse.data.id);
User.set("gender", httpResponse.data.gender);
response.success();
});
},
error:function (error){
// Error
response.error('Server error.')
}
});
});