As many of you know, Apple is moving from a certificate-based authentication with their push notifications service to a token-based one. Token-based authentication is stateless communication and therefore faster than certificate-based one. Additional advantages of token-based authentication is that tokens do not expire and you use only one token to send notifications for all of your environments.

The deadline to upgrade to the APNs provider API has been set to March 31, 2021 and after this date, APNs will no longer support the legacy binary protocol.

We know that every change comes with its inconveniences and over the last couple of weeks we’ve had many clients asking: "Should I modify something for my app, so I can have push notifications working?" - No worries! We took the care to provide you with all the actions you need to perform in this simple guide.

Basically you’ll need to take two easy steps - Receive Authentication Key from Apple and Set the credentials to your SashiDo App

Receive Authentication Key from Apple

To generate an APNs auth key, visit the Apple Developer Member Center and follow the steps below:

1. Go to Certificates, Identifiers & Profiles.
2. Click on Keys from the Menu on the left.
3. Add a new key - from the + button in the upper right corner.
4. Next, you’ll need to enter a Key Description Name and select the service you want enabled. In our case that’ll be APNS.
5. Next, press the Continue button.
6. You are automatically landed to a page with the option to Download the .p8 auth key file.

Set the Credentials to your SashiDo App

For sending push notifications, Apple requires the following information about your app - BundleId, KeyId and TeamId. So that’s the credentials you’ll need to add to your SashiDo app.

1. Go to your Dashboard -> App -> App Settings -> Push -> Apple Push Tokens and click Upload a File.

2. Upload the .p8 file and enter your credentials

BundleId - The BundleId of your project.
KeyId - That’s the KeyId for the Authentication token.
TeamId - That’s the ID for your Apple Account. You can find it from “View Account”.

3. Et Voila! Your APNS token is uploaded and you can start sending millions of push notifications per minute with SashiDo’s Push Notification Service.

We would recommend you to remove the old .p12 file from your SashiDo app, once you switch to the APNS token-based authentication.

Well, that’s all folks! If any questions arise, our team is always happy to help! Reach us at support@sashido.io.

Happy Coding!

It’s no secret Node.js is one of the most widespread frameworks for writing apps nowadays. Though with the rise of Cloud-based Machine learning popularity, finding ways to stay on top of the trends by adding machine learning-based functionalities is becoming vital for Node.js developers and the success of their apps.

If you’re one of those app creators banging their heads about how to introduce machine learning to your Node.js project, let me give you a break by saying that the opportunity to train Machine Learning models is not a reserved space only for experienced Data Scientist and ML engineers anymore. Google’s Teachable Machine tool empowers you to create and export your own model in the browser without any prior machine learning experience needed.

In the following lines I’ll show you how to train and load an Image classification model to your Node.js application in less than 10 minutes.

Content:

1. Machine learning for dummies - It's that simple!
2. Train a Machine Learning Model with Teachable Machine
3. Export to Tensorflow.js
4. Install NPM @sashido/teachablemachine-node package
5. Usage examples
   5.1 Plain Node.Js
   5.2 Express
6. Conclusion

1. Machine learning for dummies - It's that simple!

To be absolutely sure this approach is fit for machine learning beginners, I’ve personally put the simplicity of Google's Teachable Machine to the ultimate test with my mom who has no idea what machine learning is. It was not only fun, but she didn’t have any issue building a powerful image classification model that recognizes her cat amongst a bunch of other photos with very little data. 🐈 So if you have any doubts about the complexity of training a model, have no fear - Teachable Machine makes this complex task a piece of cake!

So far, so good. Now you probably wonder how to load your model into your project and make it work for you. Well, our team decided to jump in and offer an easy and open-source solution for serving machine learning models in a live environment. Et, voila - @sashido/teachablemachine-node is here to save the day and help you utilize a Teachable Machine image model into a Node.Js project out of the box. Simple, right?

2. Train a Machine Learning Model with Teachable Machine

Currently, the teachablemachine-node recognizes only image models. After a thorough analysis of the field, we figured that the greatest demand is for training image models and decided that’s the place to start. Moreover, image models serve well in many cases, such as object detection(a trendy machine learning example in real life is this fun Mask detection project), object recognition, image moderation and so many more.

Gathering samples is with no doubt the fundamental first step from training a model. You can use some open datasets, free photo platforms, own data or simply use your PC's camera to collect data. Teachable Machine allows both ways - you can load preselected images or directly use your camera to collect data.

Split the photos into as many classes, as you need. Once done, hit the ‘Train Model’ button and leave it to the Teachable Machine. Training might take a while, depending on the dataset volume. Have patience and do not switch the tab. 😊

For further insight on your model’s performance click the Advanced option

3. Export to Tensorflow.js

Once your model is trained and you’re satisfied with its accuracy, it’s time to export it. Make sure that you select Tensorflow.js format when exporting. That way your model will be uploaded (for free) and you will receive an access URL.

Next you’ll use this shareable link to load the model into your Node.js project.

4. Install @sashido/teachablemachine-node

Simple as it can be, just install using npm or yarn:

Install using npm

npm install @sashido/teachablemachine-node

Install using yarn

yarn add @sashido/teachablemachine-node

5. Usage examples

Our @sashido/teachablemachine-node makes loading an image model trained with Teachable Machine in your Node.Js project a child’s play.

5.1 Plain Node.Js

Just with a few lines of code the Teachable Machine model is loaded into your project. Simply invoke classify and handle the predictions.

const TeachableMachine = require("@sashido/teachablemachine-node");

const model = new TeachableMachine({
  modelUrl: "https://teachablemachine.withgoogle.com/models/r6BBk-hiN/"
});

model.classify({
  imageUrl: "https://media-blog.sashido.io/content/images/2020/09/SashiDo_Dog.jpg",
}).then((predictions) => {
  console.log("Predictions:", predictions);
}).catch((e) => {
  console.log("ERROR", e);
});

5.2 Express

As easy as the example above, you can also load your model in an Express app.

const express = require("express");
const TeachableMachine = require("@sashido/teachablemachine-node");

const model = new TeachableMachine({
  modelUrl: "https://teachablemachine.withgoogle.com/models/r6BBk-hiN/"
});

const app = express();
const port = 3000;

app.get("/image/classify", async (req, res) => {
  const { url } = req.query;

  return model.classify({
    imageUrl: url,
  }).then((predictions) => {
    console.log(predictions);
    return res.json(predictions);
  }).catch((e) => {
    console.error(e);
    res.status(500).send("Something went wrong!")
  });
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

Conclusion

In the last decade, Machine Learning has matured from a research field to applied business solutions. Luckily there’s no need to wait for another decade to upgrade your project with some cool machine learning based features - Teachable Machine gives you an opportunity to flatten the learning curve and easily train Machine Learning models of your own.

And now with the @sashido/teachablemachine-node you also have a fast and simple way to load any image Teachable Machine model to your Node.js application. Yes, it is that simple!

Check the Awesome Teachable Machine list, full of fantastic learning and inspiration resources, detailed tutorials and useful tools, that will help you bring your creative ideas to life!

In the long run, our RoadMap includes support for Pose Models, Audio Models, Gifs and Videos, so you can train and load all kinds of Teachable Machine Models.

Don’t be shy and let us know which's the one you want to use first and we’ll take care of the rest. We’d love to chat, just write to us at hello@sashido.io.

Happy Coding!

With the approximately 4.54 billion internet users(June 2020) worldwide, generating an unprecedented quantity of content, moderation is becoming a heavier task by the day! And the number of active users and apps on the market is constantly steeping. Left unsupervised, users can freely share any kind of content and create tons of digital garbage.

Naturally, content moderation is becoming a mandatory feature for each web or mobile application. But manual moderation is extremely time-consuming and surely stressful and Machine Learning solutions come quite pricey. So many drawbacks! Our team loves nothing more but a good challenge, so we rolled up our sleeves determined to aid developers in this heavy task and offer a solution.

Here, we are presenting the final piece of our simple, affordable and most-importantly effective fully-functional Content Moderation Service. It is built entirely with open-source libraries and can be integrated into any Parse Node.JS project and hosted anywhere.

Agenda

1. Background
2. The Problem
3. The Solution
4. Moderation Preferences
5. DB Schema
6. Admin Panel
7. Configuration and Deployment
8. Fin

Background

The project was decided to come in three parts, each more advanced than the previous. We committed this way to give you the opportunity to pick the piece you need and integrate it into your application, without any hassles. Nothing less, nothing more!🙂 So far we’ve released:

1. Image Classification REST API - The first part of this service holds an Image Classification REST API that works with NSFW.JS. NSFW.JS is an awesome library developed by Gant Laborde that uses Tensorflow pre-trained ML models. The API has quite plain logic - given an URL, it returns predictions how likely the image falls into each of the following classes - Drawing, Neutral, Sexy, Porn and Hentai.

More details you can find at the following:

• Content Moderation Service with Node.JS and TensorFlow. Part 1: REST API. A blog post that gives details on our team’s inspiration, how the API works and what’s the tech Stack used for all three project stages.
• Image Classification REST API GitHub - In case your project needs only REST API image classification, clone the repo and follow the README.md.

2. REST API + Automation Engine - The Automation Engine is tightly coupled with the REST API. Basically, it’s work consists of checking how the classification of a certain image corresponds to the parameters you pre-define as safe for your project. The process is automated with a Parse Server afterSave trigger.

For further insight check:

• Content Moderation Service with Node.JS and TensorFlow. Part2: Automation Engine - An article explaining the purpose and settings of the Automation Engine.
• Content Moderation Automation GitHub - For all folks who want to build a moderation interface of their own, but could take advantage of the moderation automation.

Our blog offers a synthesized explanation of the logic behind the REST API and the Automation Engine, so we would strongly recommend you to have a look at the articles before continuing.

The Problem

With the REST API and AUTOMATION ENGINE already put forth, the problem is almost solved. After all, the decision-making process for a great number of user-generated content is already automated and the number of pictures that require manual moderation has drastically decreased.

Unfortunately, for manual moderation you surely need to go through photos one by one. Next, you need to decide for each of the images if it is safe or toxic for your specific audience and apply your decision. All that combined may once again become a tedious task.

If you look at Instagram with its 100 million+ photos uploaded per day or Facebook with more than 120 million fake profiles you can imagine that the count of inappropriate photos daily can also reach 7 digit numbers. Even if your project can’t compare with these giants yet and your pile of images for moderation is significantly smaller it still remains a boring burden

The final touch of our Content Moderation Service puts an end to this issue by providing a super user-friendly interface that makes manual moderation all fun and games.

The Solution

To cope with the situation and make the most of it, we'll take all photos flagged from the Automation Engine for moderation and display them in an eye-pleasing Admin Panel that empowers you to approve or reject a picture with just a click.

We combine the REST API and Automation Engine with an exquisite Admin Application interface, where all users’ images that need manual moderation are stacked up for approval. It’s desktop and mobile-friendly, easy to operate and empowers you to go through a huge pile of photos in just a few brief moments.

As in the previous releases, we’ll once again use a SashiDo app for all examples. Because it is easy, fun and all infra hassles are left behind. 😊

Moderation Preferences

Hopefully, you’ve already gone through our Part 2: Moderation Automation article and you can skip this section. However, if you didn’t have the chance to read the previous blog post, we’ll go over the Moderation Preferences briefly once more, as they are an essential component.

To put in a few words, the moderation preferences are the criteria specifically set for your app which images will be automatically approved from the automation engine considered safe and which will be rejected.

Therefore, you need to carefully review which classes are dangerous or unwanted to your users. The photos classified above the max values that you set will be automatically marked deleted, the ones lower than the min values -> auto-approved, all in between go to our Admin App for manual moderation.

For example, if you’ve created an innovations app, where enthusiastic engineers present their AI robot ideas, you’ll most probably consider Sexy, Hentai and Porn classified images as inappropriate. Drawing seems a bit grey area, as you might want to allow robot sketches. Here is one example of how such moderation preferences can be adjusted:

{
  "Sexy": { "min": 0.4,  "max": 0.8  },
  "Drawing": { "min": 0.4, "max": 0.9 },
  "Porn": { "min": 0.4, "max": 0.8 },
  "Hentai": {  "min": 0.2, "max": 0.8 }
}

Let’s set these params and upload some suspicious pictures like the one below, which falls between the min and max values.

See, it’s directly stacked up for approval into the Admin App. Cool, right?! Still, in the long run, it all depends on your particular use-case and judgment.

No worries, we’ve made sure to provide you with an easy way of adjusting the moderation preferences on the fly.😉 We’ll save those as moderationScores config setting for the project, but more on that in the Configuration and Deployment Section.

The right moderation preferences settings leave more room for the automation to make the decisions and untie your hands for cooler stuff!

DB Schema

The Database Schema is the other must-mention unit and it is also related to the Automation Engine and explained in detail within our previous blog post on Moderation Automation. The idea is that you need to keep the naming and add a few columns to your DB to store the Automation Engine’s results and NSFW predictions.

1. The afterSave automation is hooked to a collection UserImage by default. To use straight away after deployment, you should either keep the same class name or change with the respective one here into your production code.
2. To keep a neat record of the REST API predictions and Automation Engine results, you will need to add a few columns to your Database collection that holds user-generated content.

• isSafe(Boolean) - If an image is below the min value of your moderation preferences, it’s marked isSafe - true.
• deleted(Boolean) - Likewise, the Automation Engine will mark the inappropriate pictures, as deleted - true. Those pictures won’t be automatically deleted from the file storage.
• moderationRequired(Boolean) - Those are loaded in the Admin Panel for manual moderation.
• NSFWPredictions(Array) - Stores the NSFW predictions as json for this image.

3. Last but not least you need to add an isModerator column to the predefined _User class. It’s again of type boolean and allows you to manage access to the Admin Panel for different users.

Well, that’s about all preparations needed to kick it off! Next, we’ll check the rudiments of the last fragment - the Admin Application and move on to deploying in production.

Admin Panel

Our awesome engineering team built a plain and chic ReactJS-based Admin Application to put the final touch. Its primary mission is allowing you to go through all images that require manual moderation and make a decision in a blink of an eye. We’ve chosen ReactJS, as it is by far the most popular front-end framework loved by many developers.

Let’s check briefly the features of the Admin panel and how it helps:

• First thing comes first, we have made a basic login/logout functionality.
• At SashiDo we truly believe that security should be a top priority for every project, so we made sure to provide you with a way for restricting access to the Admin app. You can grant access to the app for your trusted partners by setting isModerator=true in the databas.

• All pictures that are flagged by the Automation Engine as moderationRequired=true are displayed in a beautiful interface, which makes manual moderation a fun play.
• Just below each picture you have a useful scale showing the classification result for most hazardous classes - Sexy, Porn and Hentai.
• You approve or reject a photo with a simple click or swipe. As easy as it can be!😊
• And it gets even better! The Admin app is desktop and mobile-friendly, which makes it the ultimate time-saver. You can moderate your app’s content even from the subway, while on your way to work, the restaurant or the bar.

All parts of this project are open for collaboration. Fork the repo, apply your awesome ideas and open a pull request!

Configuration and Deployment

Configuration

Parse Server offers two approaches for app config settings. Parse.Config is very simple, useful and empowers you to update the configuration of your app on the fly, without redeploying. The trouble is configs are public by design. Environment variables are the second, more secure option, as these settings are private, but each time you change those your app is automatically redeployed. We’ll move on wisely and use both. 😉

Parse.Configs

• moderationScores - save the moderation preferences for your app in a Parse.Config object. That will allow you to update and fine-tune criteria any time you need on the fly.
• moderationAutomation - add this boolean option that makes enabling/disabling content moderation automation an effortless process finished with just a click when needed. For example, when you want to test the new code version without automation.

To set the configs for your SashiDo application go to the App’s Dashboard -> Core -> Config. The final result looks like:

Environment Variables

For production, we'll set the NSFW model URL, NSFW Model Shape size and Config caching as environment variables.

• TF_MODEL_URL - SashiDo stores three pre-trained ready for integration nsfw models that you can choose from.

• TF_MODEL_SHAPE_SIZE - Еach model comes with its shape size

• CONFIG_CACHE_MS variable. It will serve us for cashing the Parse.Configs and the value you pass is in milliseconds.

In SashiDo set the environment variables for your projects from the App's Dashboard -> Runtime -> Environment variables. Have a look at all you need:

For this project, we have preset the Mobilenet 93 model. However, you can always choose a different one. Want to test out different options and evaluate each model’s performance? Simply check the NSFWJS Demo page. 🙂

Deployment

SashiDo has implemented an effortless automatic git deployment process, so simply make sure your SashiDo and Github accounts are connected. Next, follow these simple steps:

1. Clone the repo from GitHub.

git clone https://github.com/SashiDo/content-moderation-application.git

2. Set the configs and env vars in production.

• checked ✔

3. Add your SashiDo app as a remote branch and push changes.

git remote add production git@github.com:parsegroundapps/<your-pg-app-your-app-repo>.git
git push -f production master

Voila!!! You can leave content moderation to the newly integrated service and go grab a beer. Cheers 🍻!

FIN!

All chunks of the Moderation Services are already assembled. We would love to have your feedback on what other ready-to-use Machine Learning services can help your projects grow. Don’t be shy and share your thoughts at hello@sashido.io.

And if you’re still wondering about where to host such a project, don’t forget that SashiDo offers a Free trial, no credit card required as well as exclusive Free consultation by SashiDo's experts for projects involving Machine Learning.

Happy Coding!

Over the last weeks, our team successfully has taken on the challenge to develop a simple and yet effective Content Moderation Service. The end goal is to help app creators keep their projects safe for work and free from abusive images, without spending too much time and effort in content moderation.

The solution comes in a brief series of just three tutorials that present a fully-functional Open-Source Content Moderation service with ReactJS based Admin Panel that can be easily integrated into every project even if this is your first encounter with Machine Learning.

Agenda

1. Background

2. The Problem

3. The Solution

4. Automation Engine

• Moderation Preferences
• The Pure Automation Process
• Database Schema
• Moderation Preferences Tuning

5. Manual Moderation

6. Configuration and Deployment

7. What is next

Background

We have already released the first piece of our moderation system just last week. It offers a ready-to-integrate image classification REST API, which uses NSFW.JS to return predictions how likely a certain image is categorized as Porn, Sexy, Hentai, Drawing or Neutral.

In case you missed the previous article about building the REST API, we would strongly recommend you to have a look now, as it gives further insights on the motivation behind this service, stack used, API setup and configuration.

The Problem

Solely classification of images, still leaves us with the task to manually moderate them one by one... and if you’re lucky enough to have many active users, the total number of pics for approval may easily get your head spinning.

Let’s say we have a growing self-training fitness application with a social element to it. Everybody wants a beach body...and they want to show it off! 😄 To stay on track and motivate each other, our users upload photos of their progress.

Now, imagine it’s a relatively medium-sized app with 5 000 daily users and 5 000 photos are updated every 24 hours. That makes 35 000 per week and 150 000 per month. WOW! Do we need to set aside a budget for content moderators? Or go through 150.000 pictures manually each month? No, thanks! There’s gotta be an easier way.

Instead of examining a huge pile of photos, we will put Machine Learning into action and upgrade the Image Classification REST API with automation logic that will significantly cut down the number of photos for manual moderation.

The Solution

We already have an easy way of classifying images, but going through all the results still is quite time-consuming...and to be honest - not really fun. So to optimize the process - we will add automation.

As in the first tutorial, we will use a SashiDo hosted app for the examples, so we can spare any infrastructure hassles. Anyhow, the code is open-source and can be integrated into projects hosted on any other provider that supports fully featured NodeJS + MongoDB - Parse Server or even cloud-hosting solutions like Digital Ocean and AWS.

This second part of our moderation service holds altogether the Image Classification API and Moderation Automation Engine. You can simply clone the project from SashiDo’s GitHub repo.

git clone https://github.com/SashiDo/content-moderation-automations

Next, deploy it to production and set the parameters defining which photos will be considered as safe or toxic. Simple as that! 😊 But wouldn’t be nice to have some context what’s all about?

Automation Engine

The entire service is built on top of Parse Server (NodeJS Backend framework) and uses Cloud Code for all server-side logic. To solve the task at hand and automate the decision making process we use Simple Cloud Code Triggers and build the process around a few easy steps. Basically, the fundament of the Automation Engine is to determine whether an image is considered safe or harmful for your users based on your predefined ranges.

Moderation Preferences

In the beginning, you need to define which of the five NSFW classes and values can contain disturbing images and require moderation, i.e. which prognoses are considered safe and which toxic.

For our fitness application, for example, images with classification Hentai > 0.8% are absolutely intolerable and we’ll want to directly flag those for deletion. Briefly, the idea is to define all classes and value ranges that will require moderation, e.g:

{
  "Sexy":   { "min": 0.5, "max": 0.8 },
  "Porn":   { "min": 0.4, "max": 0.8 },
  "Hentai": { "min": 0.4, "max": 0.8 }
}

As defining your moderation preferences is of great importance, we’ll pay some special attention to its tuning later on.

The Pure Automation Process

The automation process is integrated with Parse Server afterSave trigger, which self-executes once a change to the class holding user-generated content is made.

The logic inside is simply to check if the newly uploaded photo is safe, toxic or requires manual moderation and save the result to the database.

For the above-mentioned parameters, once we integrate the Automation Engine, it will identify all pictures that classify below the min values as safe and the ones above the max values - toxic. The in-between results require manual moderation.

In this project the afterSave is hooked to a collection named UserImage. To use straight away after deployment, you should either keep the same class name or change with the respective one here into your production code.

Of course, it is up to you how these images will be handled on the client-side. You can also extend the Engine logic and customize server-side in a way corresponding to the specific use case, applying auto-deletion of toxic images for example and so on.

More information about the implementation of the Automation Engine and the Trigger you can find in the repo - NSFW Image Valuation and Cloud Trigger Automation

Database Schema

Keeping a neat record of classification and moderation actions also falls into the best practices that save time and effort. Storing information for each image gives us a clear history of why for instance it has been flagged as rejected or approved. However, you need to make some adjustments to the DB Schema and add the following columns to the DB collection that stores users’ images.

• isSafe(Boolean) - If an image is safe according to the moderation preferences, the Automation Engine will mark isSafe - true.
• deleted(Boolean) - Likewise, the Automation Engine will mark the inappropriate images, as deleted - true. Those pictures won’t be automatically deleted from the file storage. Good practice suggests toxic images should not be erased, as they might help you detect abusive users. For example, we can easily check how many indecent photos are uploaded from a specific user and ban him from the app after a certain count that makes clear this is not an involuntary mistake but intended action.
• moderationRequired(Boolean) - All images that lay in between the isSafe and the deleted mark. Manual moderation is required for those images!
• NSFWPredictions(Array) - Stores the NSFW predictions as json for this image.

The automation engine will take care to fill all data inside these columns respectively, once a photo is uploaded.

To learn more on how to upload your files with a Parse SDK you can take a look here: Uploading file with Parse JS SDK

Moderation Preferences Tuning

Evaluating which images are safe and which inacceptable is crucial and individual for every app or business. There are as many different preferences, like the apps on the market and no clear-cut, recognized standards.

For example, in our fitness application, uploading sexy images of well-shaped bodies after a completed program makes perfect sense. However, nudes are highly undesirable. And on the other hand, if we have a children’s app, where pre-school kids upload drawings - sexy photos are also out of boundaries.

You have to take into account which parameters match your needs best and set the ranges respectively. From then on our content moderation service provides a flawless way to adjust these settings. We save the Moderation Preferences into a moderationScores config parameter prior to deployment. Such an approach makes changing the criteria in times of need or for different projects as easy as pie! 😉

Examples

Let’s see how the automation will behave with some examples of suitable moderation parameters. We’ll set different moderationScores that match the respective audience for our fitness application and the one for children's art and check the results.

Quick throwback - the REST API classifies image probabilities 5 classes: Drawing, Hentai, Neutral, Porn, Sexy. If any of these classes is disturbing for your users, include it to the moderationScores.

1. Fitness Application

Let’s take the fitness Application we already mentioned for our first example. We decided that sexy photos are perfectly okay and do not need moderation, hence this class has no place in the moderationScores config. We’ll just add Porn and Hentai, as this is undesirable content for our users. Next, let's also include the Drawing class since we want fitness photos only. Here’s one recommendation for moderation preferences:

{  
  "Drawing": { "min": 0.4, "max": 0.8 },
  "Porn": { "min": 0.4, "max": 0.8 },
  "Hentai": { "min": 0.2, "max": 0.8 }
}

Let’s upload this sexy pic of woman training and see what happens. 🙂

The prediction we get from the API is:

{"className": "Sexy","probability": 0.9727559089660645},
{"className": "Neutral","probability": 0.01768375374376774},
{"className": "Porn","probability": 0.009044868871569633},
{"className": "Drawing","probability": 0.0004224120930302888},
{"className": "Hentai","probability": 0.00009305890125688165}

As the picture doesn’t fall in any of the classes that require moderation, the upload is automatically approved and we get the following result in the database:

2. Children’s drawings platform.

While the photo above is perfectly fine for our fitness app example, it can’t be defined as a kid’s drawing for sure. Therefore it has no place on our app for preschoolers’ art. Also images that have even the slightest chance to be categorized as Hentai or Porn are definitely off the table. If only children’s drawings should be uploaded, we can include the Neutral class for moderation as well, but select higher values, as there might be a child holding a drawing for example.

Take a look at the parameters we’ve set to protect children and how the Automation Engine handles the same photo once we change the moderationScores.

{ 
  "Porn": { "min": 0.1, "max": 0.4 },
  "Sexy":  { "min": 0.1, "max": 0.6 },
  "Hentai": { "min": 0.1, "max": 0.4 } ,
  "Neutral": { "min": 0.4, "max": 0.9}
}

As already established - moderationScores values are strictly specific, so even though we’ve shared some examples, our recommendation is to put some serious thought on fine-tuning the parameters to match your needs best!

Best thing to do is to set some default parameters, like the ones we suggest above and test with some real pictures from your app. Take 50-60 images that you consider inappropriate and monitor the NSFW predictions. This is a safe and effective way to calibrate the settings according to the beat of your project.

Manual Moderation

Next week we will bundlе the Image Classification REST API and Automation Engine with an impeccable React-based UI. This will allow you to rapidly make a decision for all photos that require manual moderation and apply action with just one click.

Still, if you can’t wait to add an interface to the moderation service, you can build an Admin panel of your own. On SashiDo, you can easily build an Admin panel with the JS technologies that please you most - Angular, React, Vue… just take your pick. 🙂

Here’s an example of how to get all images which require moderation from the most-used Parse SDKs and from Parse REST API.

JS SDK

const query = new Parse.Query("UserPicture");
query.equalTo("moderationRequired", true);
query.find().then((results) => {
 console.log(results);
});

More information about how to work with the Parse JS SDK can be found in the official docs

Android SDK

ParseQuery<ParseObject> query = ParseQuery.getQuery("UserPicture");
query.whereEqualTo("moderationRequired", true);
query.findInBackground(new FindCallback<ParseObject>() {
    public void done(List<ParseObject> UserPicture, ParseException e) {
        if (e == null) {
            Log.d("isSafe", "Safe images retrieved");
        } else {
            Log.d("isSafe", "Error: " + e.getMessage());
        }
    }
});

More information about how to work with the Android SDK can be found in the official docs.

iOS SDK

let query = PFQuery(className:"UserImage")
query.whereKey("moderationRequired", equalTo:true)
query.findObjectsInBackground { (objects: [PFObject]?, error: Error?) in
    if let error = error {
        // Log details of the failure
        print(error.localizedDescription)
    } else if let objects = objects {
        // The find succeeded.
        print("Successfully retrieved images for moderation")
        }
    }
}

More information about how to work with the Parse iOS SDK can be found in the official docs.

REST API

curl -X GET \
  -H "X-Parse-Application-Id: ${APPLICATION_ID}" \
  -H "X-Parse-REST-API-Key: ${REST_API_KEY}" \
  -G \
  --data-urlencode 'where={"moderationRequired": true}' \
  http://localhost:1337/1/classes/UserImage
});

More details on REST Queries you can find in the official Parse REST API Guide. And SashiDo users can test REST requests from a super-friendly API Console that’s built in the Dashboard.

Configuration and Deployment

Hopefully, you now have a clear image of how the Classification REST API and Automation Engine work together. All that’s left is to set the configs. Apart from the moderationScores, we’ll include an option to enable/disable the automation and config caching.

Configuration

Parse Server offers two approaches for app config settings Parse.Config and Environment Variables. What’s the difference? Parse.Config is a very simple and useful feature that empowers you to update the configuration of your app on the fly, without redeploying. However, the downside is that these settings are public, so it’s not recommended for sensitive data. Environment variables, on the other hand, are private but will trigger a redeployment of your project each time you change something. As always, truth is somewhere in between and we’ll use both!

Parse.Configs

We’ve chosen to keep the moderationScores as a Parse.Config, so we can update and fine-tune criteria on the fly.

Also, we’ll add moderationAutomation option of type boolean. It gives us a way for enabling/disabling content moderation automation with just a click when needed. For example, when you want to test the new code version without automation.

Environment Variables

If you have already integrated the first piece of our service - the image classification API, then TF_MODEL_URL and TF_MODEL_SHAPE_SIZE are already set to your project. As these are a must, let me refresh your memory for the available options.

All that’s left to add is the CONFIG_CACHE_MS variable. It will serve us for cashing the Parse.Configs and the value you pass is in milliseconds.

Here are all the environment variables you need.

Deployment

SashiDo has implemented an automatic git deployment process following The Twelve-Factor App principle. To deploy the Automation Engine, first connect your SashiDo account to Github.

Once done, continue with the following simple steps:

1. Clone the repo from GitHub

git clone https://github.com/SashiDo/content-moderation-automations.git

2. Set the configs and env vars in production

• checked ✔️

3. Add your SashiDo app as a remote branch and push changes

git remote add production git@github.com:parsegroundapps/<your-pg-app-your-app-repo>.git
git push -f production master

Missing something? Check the README.md for details. And don’t forget to drop us a line of what you would like to see also included in this article at hello@sashido.io 🙂

TA-DA!🎉 You’re now equipped with fully functional Content moderation logic that will surely spare you a lot of time.

What is Next

The first two chunks of the Moderation Services are already assembled. The icing on the cake comes with the third part - a beautiful ReactJS Admin Panel that turns even the most boring tasks into a game. 😄 Check the demo!

And if you’re still wondering about where to host such a project, don’t forget that SashiDo offers a Free trial, no credit card required as well as exclusive Free consultation by SashiDo's experts for projects involving Machine Learning.

What is your specific use case and what features would you like added to our moderation service? You're more than welcome to share your thoughts at hello@sashido.io.

Happy Coding!

The Open-Source Content Moderation Service we have prepared for you is so simple and elegant to use, that even if you do not have any knowledge about algorithms, it won’t matter! You just need to know, it’s using Machine Learning … it’s trendy! ;)

Agenda:

1. The Problem
2. The Solution
3. The Stack
4. Development Environment
5. API Usage Examples
6. File Structure
7. NSFW Models
8. Deploying on Production
9. What comes Next

The Problem

Publishing user-generated content always comes with a risk and moderation is a must! Going through piles of disturbing content, however, is time-consuming and seriously stressful. Big companies like Google and Facebook have entire teams dedicated to removing offensive content, but that’s a luxury we can’t all share. Not to mention that automating this process can come quite pricey & require a high level of expertise.

However, advances in computer processing power, storage, data tools, web, etc made machine learning technologies more and more affordable. Machine Learning has already matured to the point where it can be a vital part of various projects of all sizes. All this inspired our team to roll up our sleeves and create a fully-functional Content Moderation service built entirely with Open-Source tools and libraries, which is easily maintained and can be integrated into any Node.js project effortlessly.

The Solution!

In a brief series of three tutorials, we will build with you a fully functional Open-Source Content Moderation service with ReactJS based Admin Panel. It is designed to be easily integrated into every project even if this is your first encounter with Machine Learning. ;)

Here’s what you’ll get by the end of this hattrick:

• Restful APIs, so you can flawlessly integrate content moderation logic in every project with user generated content.
• Content Moderation Automation Engine - A straightforward and effortless way to remove all unseemly images. Set the params which decisions should be taken by the ML and for which manual moderation is needed, with no hassle.
• Ready-to-use Mobile-first React JS Moderation application - A beautiful admin panel, so your team can conveniently moderate and manage all images that require manual assessment from an impeccable UI, no additional coding required. Check out our demo to have a sneak peek at the Admin App and feel the power in your hands!
• A cost-efficient solution - Our mission is to bring Machine Learning closer to single developers and teams of all sizes by making it affordable. SashiDo managed to drop all costs to the bare minimum of $4.95 for 1 000 000 predictions.
• No need for Machine Learning knowledge or skills to get this working!!!
  
  

Examples and Demos

Image Source	Image Source	Image Source
Classification Result	Classification Result	Classification Result
[{ "className": "Neutral", "probability": 0.93821 }, { "className": "Drawing", "probability": 0.05473 }, { "className": "Sexy", "probability": 0.00532 }, { "className": "Hentai", "probability": 0.00087 }, { "className": "Porn", "probability": 0.00085 }]	[{ "className": "Sexy", "probability": 0.99394 }, { "className": "Neutral", "probability": 0.00432 }, { "className": "Porn", "probability": 0.00164 }, { "className": "Drawing", "probability": 0.00006 }, { "className": "Hentai", "probability": 0.00001 }]	[{ "className": "Drawing", "probability": 0.96063 }, { "className": "Neutral", "probability": 0.03902 }, { "className": "Hentai", "probability": 0.00032 }, { "className": "Sexy", "probability": 0.00001 }, { "className": "Porn", "probability": 0.00005 }]
Neutral Demo	Sexy Demo	Drawing Demo

The Stack

For the purpose of this article, we will implement image classification into a SashiDo application, as such an approach will allow us to complete the task at hand masterly in no time 😊. If you have your project elsewhere, no worries - our content moderation service is open-source and can be hosted on any other platform that supports fully featured Node.js + MongoDB or even cloud hosting providers as AWS VMs and Digital Ocean.

However, as we want to focus on the content moderation and not waste time on the infrastructure side, we decided to go serverless and use SashiDo. Have a look at how you can register and create an application in SashiDo with all Parse Server functionalities built-in.

When it comes to the tools and libraries, I’m sure you’ve asked yourself more than once - “Which one is the perfect tool to start off?”. Following the good old ‘Keep it simple’ rule we have preselected this awesome bundle for you.

• Node.js
• Mongo DB - a document database that’s used directly by the Parse Server.
• Parse Server - an open-source Backend-as-a-Service(BaaS) framework initially developed by Facebook. It comes with a bunch of built-in functionalities and can be deployed to any infrastructure that can run Node.js. To implement server-side logic, we'll use Parse Server Cloud Code. It is built directly into the Parse Server and we hope you’ll find it quite straightforward and easy to use.
• TensorFlow - an open-source software library by Google, designed specifically for deep machine learning applications.
• nsfw.js - an amazing JavaScript library by Gant Laborde for identifying unseemly images. Check out their cool demo at https://nsfwjs.com.
• axios - our preferred HTTP client. Of course, you can easily replace it with your favorite lib.
• Parcel.js- Parcel deserved its place here, as it’s a blazing fast, zero-configuration web application bundler.

Since the goal is to have a ready-to-use product, not only classification logic, for the upcoming tutorials we will add React to our stack. It will help us build the admin panel in Part 3 of the series.

Anyhow, today we’ll begin with building the REST API for image classification, so let’s kick it off by starting the project in a development environment!

Development Environment

Implementing new features can always be challenging and has its risks, but setting up a local environment for testing makes life easier for you. 🙂 So in case you want to apply some customizations or run a few tests before deploying in production, that’s the safe way to go.

We have developed and tested with Node.js 10.2.1 and MongoDB 3.4.X, so these are the minimum requirements.

You can find our plug-and-play service on GitHub. Then simply open the terminal into the directory you’ll use for storing and take the plunge by cloning the project.

Detailed instructions on how to proceed are available in the README file, but let me summarize the setup here as well:

1. Clone the project.

    git clone https://github.com/SashiDo/content-moderation-image-api.git

2. Copy the env.example file to a .env and set your database URL.

   cd content-moderation-image-api
   cp env.example .env

Since we are testing with a SashiDo application, there is no need to run a local instance of MongoDB. Simply get your application's Database URL from the Dashboard -> App -> App Settings -> Security & Keys.

Once you set the DATABASE_URI variable into the newly created .env file, continue with the next step.

3. Install dependencies The project holds a complete example, all you need to do to is execute:

    npm install

4. Start the local server.

    npm run dev

Et voila! Running on http://localhost:1337 displays on your terminal.

[nodemon] 2.0.4
...
[nodemon] starting `node index index.js`
✨  Built in 2.55s.
node-pre-gyp ...
...
Running on http://localhost:1337
⠙ Building index.js...The NSFW Model was loaded successfuly!
✨  Built in 16.41s.

Now that we have the classification service running locally, let’s put the focus on the usage, file structure and models.

API Usage Examples

To make you feel as comfortable as possible we have added two approaches for classifying images - from an Express route, and for all Parse Server fans - from a Parse Cloud Code Function. 🙂

cURL

The Express Router is a complete middleware and routing system. You can easily classify images in the browser or with a simple cURL request.

curl http://localhost:1337/api/image/classify?url=https://nsfw-demo.sashido.io/sexy.png

This is for (future)Parse Server fans - Simple Cloud Code Function - Cloud Code runs in the Parse Server rather than running on the user’s device. You can get predictions calling the nsfwImageClassify function from REST API or from your Android, iOS, etc app. Check the example below on how to invoke from the REST API:

curl -X POST \
  -H "X-Parse-Application-Id: myAppId" \
  -H "X-Parse-REST-API-Key: myRestKey" \
  -d '{ "url": "https://nsfw-demo.sashido.io/sexy.png" }' \
  http://localhost:1337/functions/nsfwImageClassify

Parse SDKs

You can invoke the nsfwImageClassify function from the client-side or using the Parse SDKs as well:

Android SDK

HashMap<String, String> params = new HashMap<String, String>();
params.put("url", "https://nsfw-demo.sashido.io/sexy.png");
ParseCloud.callFunctionInBackground("nsfwImageClassify", params, new FunctionCallback<Object>() {
  void done(Object predictions, ParseException e) {
    if (e == null) {
      // prediction
    }
  }
});

More information about how to work with the Android SDK can be found in the official docs.

iOS SDK

PFCloud.callFunctionInBackground("nsfwImageClassify", withParameters: ["url":"https://nsfw-demo.sashido.io/sexy.png"]) {
  (predictions, error) in
  if !error {
    // prediction
  }
}

More information about how to work with the Parse iOS SDK can be found in the official docs.

API Console

SashiDo app owners can test all Cloud Code functions from the Dashboard with just a click. Check our super-friendly API Console that also gives you the option to export any request to a cURL.

File Structure

Being well informed about the file structure is of great importance, as it puts you on solid grounds. To avoid any misunderstanding, we will give the architecture a bit of special attention.

Following the best practices, we keep all the source code in the src folder, with two subfolders - for the Cloud Code and visualization. Let’s focus on the cloud folder that holds all the image classification logic.

src/cloud/
├── ml_models/
│   ├── nsfw_model.js
├── routes/
│   ├── api.js
│   └── index.js
├── app.js
├── config.js
├── functions.js
└── main.js

Our recommendation for a structure is decoupling the API, NSFW models, and image classification logic to different files. Let me go brief over the architecture:

• nsfw_model.js - contains logic for loading the NSFW model. The Classification method also belongs here.

• config.js - instead of loading the model and shape from process.env directly each time, we’ve saved them here.

• api.js - as you’ve already guessed, here’s the heart of this project - the API. To keep things simple and move one step at a time, we have implemented just one handler. Its only job is invoking the classify method for an image and returning a prediction.

import express from "express";
const router = express.Router();

router.get("/image/classify", async (req, res) => {
 try {
   const { url } = req.query;
   const result = await nsfwModel.classify(url);
   res.json(result)
 } catch (err) {
   console.error(err);
   res.status(500).json({
      error: "Ups... Something went wrong!"
    });
 }
});

That’s it! Our API is ready to go through a pile of photos in no time helping you protect your project’s users from inappropriate content.

NB! main.js, app.js and functions.js are part of SashiDo’s predefined cloud code and the structure is Parse Server specific. Let me give a piece of information about each file’s function as such insights could help you hand over effortlessly to your project if hosted elsewhere.

• main.js - is the entry point for each SashiDo application.

• app.js - holds your Express logic, as we mount it automatically to the Parse Server Deployment.

• functions.js - is where Simple Cloud Code lives. 🙂

NSFW Models

To keep it simple, in the context of this tutorial, you can think of the Machine Learning model as a file that has been trained to recognize certain types of patterns. For our specific case, we pass the model an image and it returns a JSON of predictions how likely this image falls into each of the following 5 classes:

• Drawing — Harmless art, or picture of art
• Hentai — Pornographic art, unsuitable for most work environments
• Neutral — General, inoffensive content
• Porn — Indecent content and actions, often involving genitalia
• Sexy — Unseemly provocative content, can include nipples

SashiDo stores three pre-trained ready for integration nsfw models that you can choose from. Each of these models has different accuracy, shape size and resource consumption.

You've probably noticed that mobilenet models are far more lightweight than the inception one, which has a high RAM and CPU consumption. That's why for the development environment we have preset the Mobilenet 93. However, you can always choose a different model. To evaluate each model’s performance and check which matches your use case best, check the NSFWJS Demo page.

For our examples and demos, we’re using Inception_v3, as that’s our favorite choice. If you also choose using Inception_v3, keep in mind that your project will need more computing power. For the occasion in which SashiDo is your mBaaS provider - the minimum Engine that can handle this task is Production 2X.

Deploy to Production

1. Configuration

The configs we need to set up in production are TF_MODEL_URL for the TensorFlow Model URL and TF_MODEL_INPUT_SHAPE_SIZE for the Input Shape Size. Check the previous section to make your pick.

If you are a proud SashiDo app owner or collaborator, jump to Runtime -> Env Variables section to set the values. Please, note that any change of environment variables from the Dashboard automatically triggers a Deployment of your project. When you’re all set, the final result should be:

2. Push the project code to your SashiDo App

Having a local environment for experimenting surely pays off! You already went through the code and verified it’s behaving properly. Make sure that you've connected your SashiDo account to GitHub and safely push the changes to your production app’s master branch.

An elegant approach to go with is adding a remote:

git remote add production git@github.com:parsegroundapps/<your-pg-app-your-app-repo>.git

... and applying to the live app seamlessly.

git push -f production master

If you're keeping up with the good practice and have a testing/staging application apart from your live one, we would always advise pushing changes there first.

Naturally, pushing new code to GitHub automatically triggers a Build and Deployment of your SashiDo App.

3. Get Live Predictions

Same as with testing locally, try out calling the classify method to validate the smooth operation of the service applied. In case you forgot what are the commands, refresh your memory here.

Well, that’s it! A piece of cake, right. 🙂

What comes Next

• Content Moderation Service with Node.js, TensorFlowJS and ReactJS. Part 2: Moderation Automation - The next part describes in details how to add an Automation Engine and implement the logic for the automatic deletion of most hazardous images. It will be quite useful, I promise!

• Content Moderation Service with Node.js, TensorFlowJS and ReactJS. Part 3: Moderation Admin App - To put the cherry on top, we add a beautiful Admin Panel and prove that even most boring tasks may be completed with finesse.

And if you’re still wondering about where to host such a project, don’t forget that SashiDo offers a Free trial, as well as exclusive Free consultation by SashiDo's experts for projects involving Machine Learning.

Our team will be happy to hear about your specific use case and what problems our moderation service helped you solve. You're more than welcome to drop us a line at hello@sashido.io!

Happy Coding!

One of the great benefits that SashiDo gives you is full access to your database. You can not only explore your records from our super-user-friendly DB Browser but go further and connect directly to your MongoDB with a tool of your choice.

We already have introduced you to Studio 3T - an easily operated, quite fast and very well documented MongoDB client, in our YouTube video tutorial series. There we presented a demo on how to import and export collections to JSON.

Nevertheless, we often get many questions on how to migrate to SashiDo and today, I will shed more light on how you can easily migrate your data with Studio 3T. The best solution for export/import data when it comes to migration will be in BSON, as MongoDB represents JSON documents in binary-encoded format behind the scenes.

I will guide you step by step through the process, but first, let me share why Studio 3T:

Studio 3T is a fully featured IDE for MongoDB that allows users to explore their local database or to work with shards and replica sets. It is fully compatible with current and legacy releases of MongoDB and has a set of useful features for interacting with the database, including SQL queries. Customers are granted a free trial period of 30 days and discounts are available for Students, Teachers, Nonprofit Organizations and Startups. :)

On top of that, we have arranged a discount for all SashiDo customers, as we want you to have the most convenient and easy way of interacting with your database. Just contact Angelo from Studio 3T and pass on SD0619 promo code and you’ll get 20% off. How cool is that?! You can download Studio 3T from here.

Now, when we know our tool, let’s start off by connecting to your SashiDo MongoDB!

Connect to your SashiDo DB

The Studio 3T Connection Manager enables you to link to your MongoDB almost instantly. There are several options that you can use to start a connection, but for the purposes of this tutorial, I'll focus on using the MongoDB URI. The URL for your SashiDo Database can be found on the App's Dashboard -> App Settings -> Security&Key. Just click on Show Database URL and copy the address.

Next, open Studio 3T and press the Connect button in the global toolbar. This will open the Connection Manager. Click on New Connection to launch the New Connection Window. It would display several options for you to choose from. Select from URI and paste the already copied connection string. Confirm with the OK button.

Last but not least, give the new Connection an easily recognizable name and hit Save. The DB is now displayed in the Connection Manager and all that’s left is to press Connect

The cool thing is that Studio 3T will remember that connection and automatically save it, so next time you will connect with just one click!

Once you are connected, you can start exploring all great features that Studio 3T offers - Visual Query Builder, SQL Queries, In-place Data Editing, Tasks, and many more neat options. In this tutorial, we will use the Import and Export properties, which enable you to migrate data in a specified format. All JSON, CSV, BSON, and SQL are supported, together with import/export to Another Collection.

Export to BSON(mongodump)

1. First open the Export Wizard! There are two ways to do that:

• Press on Export in the Global Toolbar.

• Right-click on any server, database, or collection and choose Export Data.

2. Select Export Format. We will choose mongodump for our migration example, as this is the binary format to export a database/collection together with the indexing rules, hence is most suitable for migrations.

On the next screen select BSON - mongodump folder.

3. Pick out the folder to which the data will be exported. Move on by selecting the folder where you will export the DB. Have in mind that mongodump folders have a specific structure. This means that Studio 3T will automatically create a subfolder with the dumped database within the chosen folder, which will have the existing DB name. If you want to import this database at a later stage, you will need to rename the subfolder with the new database name.

4. Smash the Start Export button and wait a few seconds or minutes, depending on the database size. See how straightforward the whole process is:

Let’s move on and see how easy is to import data. :)

Import from BSON(mongorestore)

Well, the process here is quite similar to the one we have already gone through.

1. Connect to the new Database, where you will import the previously exported data and get its name. You will need the name to rename the subfolder of the already dumped Database, remember?

2. Rename the already existing mongodump subfolder respectively.

3. Open the Import Wizard - using the below approaches, analogous to the Export one:

• Right Click on the specific collection/database and Choose Import Collections
• From the Global Toolbar -> Import

4. Choose BSON - mongodump folder for Import Option and hit OK.

Then from the Select mongodump folder to import field choose the root folder of the dumped database. All collections that are about to be imported will display on the right side of the screen.

5. Start the import of collections by simply clicking the Execute button.

It’s simple as that! See for yourself how easy and flawless you can import a Database with Studio 3T:

Voilà! The Import is completed and you can play around with your Database directly from your super-user-friendly SashiDo DB Browser, which makes every task a piece of cake.

N.B! If you are a Windows user, note that Windows has a specific general naming convention and character limitations, which in some cases can be in controversy with the MongoDB naming system. In that line of thinking, pay attention to databases that have columns of type Pointer or Relation as these may not be properly exported/imported. Another tricky case while using Studio 3T is that mongodump creates BSON archives in .gzip, which is incompatible with Windows.

Happy coding!

We all know that communication with app users is essential for app publishers. And push notifications are probably the most effective way to speak directly to your audience. They don't get caught in spam filters, or forgotten in an inbox — furthermore, they usually provide a quite high number of click-through rates. Another strong benefit of Push notifications is that they can be a delicate reminder to use an app, regardless if it is open or not.

Exactly these great advantages are the reason for every developer to want to have a quick and easy way of Sending Millions of Push Notifications per Minute.

In this tutorial, we will walk through all mandatory steps for setting Android Push Notifications using Firebase Cloud Messaging and SashiDo Dashboard, as follows:

1. Connect your Android App to your SashiDo Parse Server
2. Create a Firebase Project and connect it to your Android App
3. Add the Firebase Credentials to SashiDo
4. Include the mandatory FCM Parse services to the Android.Manifest file
5. Create Installation and send your first Push Notification

Let’s go together through each step one by one :)

1. Connect your Android App to your SashiDo Parse Server

1.1 Add the Parse Android SDK to your Android project

First, include the JitPack repository to the build.gradle(Project:ProjectName) file of your project. Keep in mind there is one more build.gradle file and pay attention to make this change to the one that is in charge of the Project, not the Modules.

// File: build.gradle(Project:ProjectName)

allprojects {
   repositories {
       ....
       maven { url "https://jitpack.io" }
}

Then add the library to the dependencies, this will be in the different build.gradle(Module:app) folder.

// File: build.gradle(Module:app)

dependencies {
…
implementation "com.github.parse-community.Parse-SDK-Android:parse:latest_Jitpack_Version_Here"

implementation "com.github.parse-community.Parse-SDK-Android:fcm:latest_Jitpack_Version_Here"

}

Wondering how would you know which is the latest version? Simply check at https://jitpack.io/. :)

1.2 Connect to your SashiDo App

Create a new Java Class, named App.

Make sure to import Parse and Initialize your SashiDo Parse Server Application like this:

//File: App.java

import com.parse.Parse;

//   Initialize your SashiDo Parse Server:public class App extends Application

public class App extends Application {
   @Override
   public void onCreate() {
     super.onCreate();

Parse.initialize(new Parse.Configuration.Builder(context: this) 
.applicationId("YOUR_SASHIDO_APPLICATIONID_HERE")
             .clientKey("YOUR_SASHIDO_CLIENTKEY_HERE")
             .server("YOUR_SASHIDO_API_URL_ADDRESS_HERE")
             .build()
       );
   }
}

All credentials for your SashiDo app can be found at the app’s Dashboard -> App Settings -> Security & Keys section.

Continue with defining the App.java class to the AndroidManifest.xml like that:

// File: AndroidManifest.xml 

<application
   android:name=".App"
    ...
</application>

2. Create a Firebase Project and connect it to your Android App

2.1 Create a Project In Firebase

Go to the Firebase Console and click on +Add Project. Then choose an appropriate name for your project in Firebase:

Once the project is ready click on the Android logo in the Get started section by adding Firebase to your app field that is displayed. Once you select it this screen will appear:

Get the project package name from your Android App’s AndroidManifest.xml:

2.2 Add the google.json file to your Android Project

The second step requires you to download the config file. Once you download the google-services.json, make sure to include it to the app folder of your Android Studio project.

2.3 Add the Firebase SDK

Basically, you need to modify the build.gradle files, so they can use the google-services.json.

Proceed by following the steps in the Firebase Console and include the respective line to the dependencies in your build.gradle(Project:ProjectName).

//File: build.gradle(Project:ProjectName)

buildscript {
  dependencies {
	....
    classpath 'com.google.gms:google-services:latest_Version_Here'
  }
}

Then move to the build.gradle(Module:app) and include the following line to the bottom of the file:

// File: build.gradle(Module:app)

apply plugin: 'com.google.gms.google-services'

The latest versions will be embedded in the Firebase console guidance code. Still, it’s always good to know from where you can check them. Here you may find up-to-date info for the Google Services Gradle Plugin.

If you stumble upon some bumps while creating the Firebase project, check out the official Firebase docs for some hints. ;)

3. Add the Firebase Credentials to SashiDo

Maybe the easiest part from the setup ;)

Go to your Firebase Project Settings…

… Cloud Messaging tab

Copy the Sender Id and the Server Key credentials and add them to your SashiDo App from App Settings -> Push

Simple as that ;)

Hit the Save Changes button and continue with setting up the Android.Manifest file.

4. Set up the Android Manifest

Next, you will need to add the following services to the manifest:

4.1. The FCM ParseFirebaseMessagingService:

// File: Android.Manifest

<service
    android:name="com.parse.fcm.ParseFirebaseMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>

4.2. ParsePushBroadcastReceiver:

// File: Android.Manifest

<receiver
    android:name="com.parse.ParsePushBroadcastReceiver"
    android:exported="false">
    <intent-filter>
        <action android:name="com.parse.push.intent.RECEIVE" />
        <action android:name="com.parse.push.intent.DELETE" />
        <action android:name="com.parse.push.intent.OPEN" />
    </intent-filter>
</receiver>

After finishing with the Android.Manifest, you are almost ready to start sending Push Notifications to your users. Just one last step left and you are good to go!

To be able to send Push Notifications, you need to have installations, right?! Let’s see how that would work!

5. Create your first Installation

Move on to the final step - create and save the device Installation.

//File: App.java

 ParseInstallation.getCurrentInstallation().save(); 

The installation object that you save in the database contains the token of the device, which is actually used by SashiDo's Push Notification Service to send notifications.

Voilà! Now just go to your awesome project’s Dashboard and send your first Android Push Notification.

Happy Coding!

Useful docs related to this tutorial:

Oficial Parse docs on how to Configure your Clients to Receive Push Notifications

Oficial Firebase docs on how to Add Firebase to your Android Project

Our team is happy to announce that once and for all you have the opportunity to replace the little bit rusty Parse Server v.2.3.3. It is time to a leap ahead into the up-to-date versions! And we're not simply giving you one new version, but whole 3 of them to choose from - v2.8.4, v.3.0.0, and the latest v.3.1.3.

Let’s see some of the fresh advantages they are bringing :)

Cleaner Cloud Code

Improved lightweight Cloud Code syntax is a major advantage that comes with Parse Server v3. Handlers have a new interface based on promises, which achieves a more clear and readable code with the es6 async/await constructs. No need to rely on heavy then/catch blocks and respectively response.success / response.error are to be removed from Cloud Code. Follow our tutorial on how to upgrade your SashiDo app from Parse Server v2 to v3 and you will flawlessly switch to the new syntax.

Parse Server SDK 2.0

Another significant innovation present from v3 is that Cloud Code runs with Parse-SDK 2.0. Many bug fixes are implemented to the 2.0 SDK. Furthermore, containedBy and includeAll query methods are added, together with the option to fetch objects with includes.

Full-text Queries

Up to date, Parse Server has been enriched to add automatic indexing on $text indexes. That makes the search capabilities on text fields much more efficient and allows you to perform Full-Text Search without any hassle or need of workaround solutions.

Request original IP

One more well-known challenge has been resolved in the most recent Parse versions, as presently the request original IP is added to cloud code hooks, which facilitates developers that need to access the user IP easily and utilize it to fetch geolocation for example.

Live Query CLPs

This is definitely an amendment that stands out and it is available in the new Parse versions that SashiDo supports. Its core idea is that CLPs are now passed alongside the object when notifying the LiveQuery server so they are handled without having to access the Database.

Share data object between beforeSave and afterSave

With version 3.0.0 another cool improvement is added to the deck - the ability to pass a context object between beforeSave and afterSave on the same object. Here is how to easily add data between the Triggers:

Parse.Cloud.beforeSave('Review', async request => {
  request.context = {
    comment: 'Great'
  };
});

Parse.Cloud.afterSave('Review', async request => {
  console.info(request.context.comment); //Great
});

Luckily, all these are integrated into the new Parse Versions that SashiDo supports and are now available to you! There are much more changes, which you may check-out in the parse-community GitHub.

Happy Coding with Parse Server v3! :)

I am sure most of you are already aware of the new Engines feature SashiDo released shortly. However, in case you missed our Announcement on how to Power up with SashiDo’s brand new Engine feature, I suggest for you to check it out now, as it is closely related to the main topic here.

After this short intro, let me get back on track and present you Builds and Deployments - awaited features by many of you that are now a fact!

Builds

Builds are generated only by specific actions you take as the following events:

• Change of the Parse Server version from the Dashboard.
• After git push to the master branch of your application repo, usually when you push changes to your cloud code.
• Manually from the Dashboard.

Once a Build is triggered, what happens is that the code from your private SashiDo GitHub repo is bundled together with the Parse Server version you chose for your app from the SashiDo Dashboard. Then a new Docker Image is created of this bundle, which contains multiple layers, used to execute code by the Docker engine on our Kubernetes clusters.

Probably it is not a surprise for any of you, that some minor syntax error present in the package.json file may cause the Build to fail. Actually, that is the most common reason, others may include a wrong NPM package name, failing of the unit tests, etc. Luckily, Build Logs are here! Now you can effortlessly follow the progress of your Build and if it fails, you will be perfectly able to localize and fix the error.

We laid out the Builds Logs with a coloured bar chart for your newest 15 Builds together with a simple List of Builds below, holding the recent 100. Last, but not least the Start Build button is in the upper right corner.

Deployment

Deployments are triggered by everything that changes the runtime configuration of your app. Here are the examples:

• Every time after Build, no argue there.
• Scaling vertically, in other words changing the type of Engines your app runs on
• Any update to your Environment Variables.
• Any change in the App Settings.
• Manual Start Deployment from the Dashboard.

To put it in a few words, the Deployment takes all of your application's artifacts and runs them to the real servers.

Deployments usually do not fail over a mistake you may have made. However, an Engine being stuck while deploying may cause the operation to fail.

We chose to display your app’s last 100 Deployments structured in a simple and neat Deployment List, holding details like creation, completion time, current status etc.

Have in mind that the last Deployment will always be with ACTIVE status. You need to have one running version of your app, right? :)

Same as with Builds, the Start Deployment button is present in the upper right corner to manually trigger the process if needed.

Fin

Well, that’s it! An awaited feature is finally present on your Dashboard. Not to mention, it is one more debugging tool in your sleeve. Take your time and explore Builds and Deployments! We’ll be looking forward to your feedback as usual!

Those of you who know us can easily guess that in the future, we plan to further upgrade Builds and Deployments and customize them with some graphs and configurations. But I will leave the details for this improvement to be a surprise :)

Happy Coding!

Here at SashiDo, we know that owning an app requires keeping neat and up to date database. Therefore you certainly will need to add, update or delete records from time to time. In this tutorial, we will focus on erasing objects and files.

For starters, we would like to share more details on SashiDo’s database and file storage model. The first thing to know is that we do not record the files themselves in your database directly. When an entry, holding a file is created, this file is immediately saved to your S3 bucket. This action will return the file URL, which is actually what is stored in your database. We've chosen this particular model, to give our clients the opportunity to have a lightweight database, with faster performance and lower costs.

In relation to our storage design, If you wish to delete an entry or a simple file from the DB Browser, you may think that it will be removed from the file storage as well. Still, this is not the case. When you delete an entry from the Database through the Dashboard or any of the Parse SDKs, the respective object still remains on the cloud storage. And if you want to remove the particular entry or file from the S3 bucket as well, a different approach will be needed. Don’t you worry, we will guide you through the process.

To illustrate better the situation, imagine you have a class “Products” in your DB Browser, which contains product characteristics and a field called “Image”, which holds a picture of the respective product. Now, let’s go through the different scenarios of erasing data.

Deleting an object

The proper way to delete an object from your file storage when erasing it from the database is by registering a handler in your cloud code with the beforeDelete or afterDelete Triggers. I would recommend you to use the beforeDelete method, as this way you can easily catch if an error appears while deleting the object from your Database and handle it accordingly.

Assuming the entry is successfully deleted from the database and no error occurs, continue with these two simple steps:

• Get the name of the removed entry, as you will need it to erase the object from the storage as well.

• Finish with a simple rest API call to your Parse Server.

You can see how to easily do that in the sample code below:

Parse.Cloud.beforeDelete('Products', async (request, response) => {
   const file = request.object.get('Image'); 
   if (file) {
       const split_url = file.url().split('/');
       const filename = split_url[split_url.length - 1];
       try {
           await Parse.Cloud.httpRequest({
               url: `${process.env.PARSE_SERVER_URL}files/${filename}`,
               method: 'DELETE',
               headers: {
                   'X-Parse-Master-Key': process.env.PARSE_SERVER_MASTER_KEY, 
                   'X-Parse-Application-Id': process.env.PARSE_SERVER_APPLICATION_ID
               }
           });
       } catch (e) {
           const error = `error deleting file ${filename} - ${e.message ||
           e.stack ||
           e.text ||
           JSON.stringify(e)}`;
           console.error(error);
           return response.error(error);
       }
   }

   response.success();
});

Still, if by any chance you have ended up with some orphaned files, but you’re unsure of their names to be able to delete them, don’t worry - we can help! For such situations you can take advantage of our Custom Development Work service and our team will provide you with a list of all your files names. The service is paid by the hour, takes 1-2 hours tops and is executed within 7 biz days, but for an exact quote and pricing contact our team at support@sashido.io.

Deleting a single file

However, deleting an entire object from your database is not the case every time. In different situations, you may need to wipe out just a single file. Well, if removing just the ‘Image’ file from our class ‘Products’ is the desired action, then the approach will be slightly different. Basically, it will involve a simple before/after object comparison, past the deletion of the file from the DB Browser. Let’s dive straight into more details and some code :)

For the situations you want to perform any actions after an object is saved, the afterSave Trigger takes places. You need to register a handler with the afterSave method and compare request.object and request.original. If in the request.object the file is missing, you simply delete it from the file storage via the REST API.

You may get a clear idea on how to proceed from the few lines of code below:

Parse.Cloud.afterSave('Products', async request => {
   const image = request.object.get('Image');
   const imageOriginal = request.original.get('Image');
   if (imageOriginal && image === imageOriginal) {
       return;
   }

   const split_url = imageOriginal.url().split('/');
   const filename = split_url[split_url.length - 1];
   try {
       await Parse.Cloud.httpRequest({
           url: `${process.env.PARSE_SERVER_URL}files/${filename}`,
           method: 'DELETE',
           headers: {
               'X-Parse-Master-Key': process.env.PARSE_SERVER_MASTER_KEY,
               'X-Parse-Application-Id':
               process.env.PARSE_SERVER_APPLICATION_ID
           }
       });
       console.info('File Deleted');
   } catch (e) {
       const error = `error deleting file ${filename} - ${e.message ||
       e.stack ||
       e.text ||
       JSON.stringify(e)}`;
       console.error(error);
   }
});

That’s it! You are all set up now to delete files from the database and the file storage :)

More detailed information can be found in the official Parse documentation, respectively for:

• TriggerRequests

• AfterDelete Triggers

• afterSave Trigger

• The Rest requests to delete a file.

Happy coding!

Multilingual communication is a powerful tool, whether you want to become an insider in another culture market or create higher value and be more efficient in your business. Therefore in order to successfully speak to the world without losing the true meaning behind your message, it is important to do it in the languages most familiar to your audience. For that reason, we decided to expand your options and get you to the next level. Now with SashiDo, you have the opportunity to send multilingual emails and multilingual user-facing pages to your users.

Setup the Multilingual Email Templates

1. Configure Users Locale

If you wish to address your customers in their own language, first you need to add a column named localeIdentifier to your application’s User class in the DB Browser. The localeIdentifier field should be of type String. In this column, you will add the respective language for communication to the current user. To minimize the chance of mistakes we decided to use a primary sub-code that identifies the language (e.g., "en"), and a sub-code in capital letters that specifies the national variety (e.g., "GB" or "US" according to ISO 3166-2). The sub-codes should be linked with a hyphen(eg. en-GB). Implementing the logic how you will collect this data is up to you :) If the field is empty or contains invalid language, the default templates will be sent to this user.

2. Manage multilingual Email Templates

To manage your multilingual email templates, you should go to the Dashboard -> Your App -> App Settings -> Emails & Hosting. At the Email Templates section, you now have the option to choose Country and Language and Add template. Hereafter choosing Country and language, please pay attention to the code displayed in the Locale field, as this is how the selected language should be entered in the localeIdentifier field. Later on, the same code should be used again when you set the user-facing pages.

As soon as you press the add button Email templates for verification and password reset are created and opened for you to customize. Just change the text by your preferences, to give your users the best experience and press Save changes button in the lower right corner.

You can edit each template's text whenever you wish, from the Manage button. Just remember to press the Save changes after you finish editing.

To delete a certain template, also first you need to go to Manage -> Delete these templates -> Save changes.

Another great feature we find of use is the ability to choose the default language for your customers. Deciding which will be the default language is of great importance since if there is no valid entry in the localeIdentifier field, the default email template will be sent. Therefore you need to choose wisely :) The default language is of note regarding the User-Facing pages too, but we will get to that later.

You can simply select the default language from the slide bar in the Default field before each language. Again press Save changes and it is set!

Setup the Multilingual User-Facing Pages

Well, multilingual email templates are a great feature, but probably you want the page that displays next to be also in your customer's language. Don't worry, we now support Multilingual User-Facing Pages too!

We know dealing with new features may be at times challenging and I will try to simplify the process for you.

1. Start with Cloud Code

As you know, the multilingual email templates that you configured earlier for your users contain some link to a respective page. Basically, there are four essential pages, that the emailed link can lead to: Successful verification, Choose password, Successfully changed password, and of course Invalid Verification link.

Each of these pages can be presented in your customers' language. All you have to do is write the desired HTML and CSS files in your GitHub repo. And of course, few lines of cloud code logic should be implemented in the Advanced Cloud Code.

Here I am offering a sample code, which you can put in the app.js file of your cloud code.

const path = require('path');

/**
 * Folder structure
 * public/
 * ├── pages/
 * │   ├── choose_password.html // default
 * │   └── en-US/
 * │       └── choose_password.html // en-US template
 */

function getUserFacingTemplate(templateName) {
  return async (req, res) => {
    let templatePath = path.join(__dirname, '../public/pages/');
    const { username } = req.query;    
    if (username) {
      

      const user = await new Parse.Query(Parse.User)
        .equalTo('username', username)
        .first({ useMasterKey: true });

      if (!user) {
        return res.end(JSON.stringify({
          error: 'unauthorized'
        }));
      }

      const locale = user.get('localeIdentifier');
      if (locale) {
        templatePath += `${locale}/`
      }
    }

    templatePath += templateName;
    return res.sendFile(templatePath);
  };
}

app.get(
  '/localized_choose_password',
  getUserFacingTemplate('choose_password.html')
);
app.get(
  '/localized_password_changed',
  getUserFacingTemplate('password_reset_success.html')
);
app.get(
  '/localized_email_verified',
  getUserFacingTemplate('verification_successful.html')
);
app.get(
  '/localized_invalid_verification_link',
  getUserFacingTemplate('invalid_verification_link.html')
);

2. Continue with User-Facing Templates

Have in mind that the folder structure is of great importance!

Here I can offer some guidance on how to add your User Facing Templates to your cloud code:

In the public directory in your cloud code repo, you will need to create a new folder, named pages.
Then in pages create a separate folder for each different language you would like to use. Every folder should be named as the value of the locale field in the multilingual email section in your application’s Dashboard. These folders will hold all the HTML and CSS files for the respective language. You can even have different CSS for each language if you wish.
With this folder structure, the user-facing pages for the default language should be placed right into the pages folder. Therefore if the content of the localeIdentifier field is unidentified or different from the languages you chose for communication, the default templates will be sent.

If you haven't had the chance to look at our previous tutorial on the topic, you can check it out here.

3. Finalize by configuring Localized User-Facing pages in SashiDo’s Dashboard

Last, but not least is telling SashiDo you want to render the localized User-facing pages. For that just go one more time to the App Settings -> Emails & Hosting. There in the User-Facing Pages section add the path for the localized templates as shown below. Actually, these will be the routes you defined earlier in the cloud code, with Express.js.

I believe that's all you need to know to get started with multilingual emails and user-facing pages. And I am sure that the users will appreciate such distinctive communication.

That’s it, you are all set now :)

Happy coding!