Develop Reference

Firebase Database -Restrict value update to only once per user

I am using Firebase Realtime databse in an android app ,
the app contains articles and I want to add the Number of views to the articles through all the app users .
The database contains a child (ViewsCount) its value (is a number)
I need that value to be updated (incremented by 1) every time an article is viewed by a new user (Concept similar to YouTube video views)
The user have to be authenticated anonymously to update the value, but should not be able to do it more than once.
I got the logic integrated into the app to do just that and works great.
But what I am afraid of is if someone tries to connect to the database outside of my app (using their own code) and keeps incrementing the value.
My current security rules are:
"ViewsCount"
{
".write": "newData.exists() && auth!==null",
".validate" "newData.val()===data.val()+1"
}
"users": {
"$user_id": {
".write": "auth.uid===$user_id",
".read": "auth.uid===$user_id ",
}
}
is there a way to restrict the update of a that value to only once per user via security rules ?.
Error :
Update :
screenshot from Simulator
Database structure

There sure is, but you'll have to do some extra work. The first thing is to track in the database who has already viewed each article. For example keep a list of their UIDs, like this:
viewedBy: {
uidOfKarim: true,
uidOfPuf: true
}
Now when somebody views an article, they write their UID to viewedBy, and at the same time increment the view count for that article. In code that can be as simple as:
DatabaseReference countRef = FirebaseDatabase.getInstance().getReference("ViewsCount");
countRef.addListenerForSingleValueEvent(new ValueEventListener() {
#Override
public void onDataChange(DataSnapshot dataSnapshot) {
String uid = FirebaseAuthentication.getCurrentUser().getUid();
Long newCount = dataSnapshot.getValue(Long.class) + 1;
Map<String, Object> updates = new HashMap<String, Object>();
updates.put("viewedBy/"+uid, true);
updates.put("ViewsCount", newCount);
}
#Override
public void onCancelled(DatabaseError databaseError) {
throw databaseError.toException();
}
}
So this code send the UID of the user and the new view count to the database. Now we update the security to only accept the write operation if the UID hasn't been stored yet and if the count is incremented by 1:
"viewedBy": {
"$user_id": {
".validate": "
auth.uid===$user_id && !data.exists() && newData.exists() &&
newData.parent().parent().child('ViewsCount').val() === data.parent().parent().child('ViewsCount').val()+1
"
}
},
The syntax is a bit long, since it checks both the ViewsCount and the ViewedBy data. The write only succeeds if it increments by 1 and is from a user who hasn't been counted yet. If they have been counted before, or don't increment by 1, the write is rejected.
There is one edge case here: if multiple users view at almost the same time, one of their writes may be rejected, because they didn't actually increment the value:
user1 user2 database
| | |
read_count -------------------> |
| | |
| read_count --------> |
| | |
| <------------------- 2 |
| | |
| | <------------ 2 |
| | |
set_count 3 -------------------> |
| | |
| set_count --------> |
| | |
| <------------------- ok |
| | |
| | <------------ ACCESS |
| | DENIED |
| | |
In this case you should retry the update operation, reading the new value and determining the correct count based on that. This is actually how Firebase transactions work behind the scenes. Alternatively, you can first read from viewedBy to see if the current user has already been counted, before trying to count them. But either way: with these rules, each user can only count once.
Update: this is how I tested these rules in the simulator:
And this is the JSON I tested with:
"52469568": {
"ViewsCount": 10,
}

This is the security rules that worked in case any one else have the same issue:
{"rules": {
"views": {
".write": "auth != null",
".validate": "newData.hasChildren(['ViewsCount', 'viewedBy'])",
"ViewsCount": {
".read": "auth != null",
".validate":"data.parent().child('viewedBy').child(auth.uid).exists()== false"
},
"viewedBy": {
"$user_id": {
".validate": " auth.uid===$user_id && !data.exists() && newData.exists() &&
newData.parent().parent().child('ViewsCount').val() ===
data.parent().parent().child('ViewsCount').val()+1
&& newData.val()===true"}},
},

bitwise operator on android : why large numbers are not equals

suppose I write some very simple tests in an android app working on simulator (marshmallow, OSX 64 bits) whith logcat output:
Log.i("test","long int = "+17301768L);
Log.i("test","long int = "+(1<<3 | 1<<8 | 1<<19 | 1<<24));
Log.i("test","long int = "+ 8607236360L);
Log.i("test","long int = "+(1<<3 | 1<<8 | 1<<19 | 1<<24 | 1<<33));
…logcat prints:
long int = 17301768
long int = 17301768
long int = 8607236360
long int = 17301770
Obviously, last line is not correct : it should be the same as the third line.
Why ?
And how can I make it working as expected ?

By default all numbers in Java are of type int. Therefore the numbers you create using the binary operations are int values, too:
(1<<3 | 1<<8 | 1<<19 | 1<<24 | 1<<33)
1<<33 = 2
1L<<33 = 8589934592
int values are limited to 31 bits + 1 bit for indicating positive/negative value.
Therefore setting the 34th bit does not change anything.
To make it work you have to explicitly use long values for all bits that does not fit into an int. You can do that by adding "L" for long to the number.
System.out.println((1<<3 | 1<<8 | 1<<19 | 1<<24 | 1L <<33)); // 8607236360

Re-implement a preference screen in Android

In my app, I'm trying to have a list of custom servers, and I want to be able to add them and edit their respective settings individually.
The standard Android PreferenceFragment looks and works great for my purposes. Is there a way I can use it to edit selected items? Or, alternatively, can I re-create its look and behavior easily?
In a nutshell :
---------------- ----------------
| +| | |
| Item A | | Preference |
| Item B | --> Click on "A", "B" or "+" --> | Screen |
| ... | | |
| | | |
---------------- ----------------
Note that I also know how to use a screen hierarchy, and that doesn't fit the bill since I can't add or remove items dynamically, while the app is running.

From what I understand, you want to add preferences dynamically in your fragment.. Am I right??
Just look at this sample I found:
onCreate(){
this.setPreferenceScreen(createPreferenceHierarchy());
}
public PreferenceScreen createPreferenceHierarchy(){
PreferenceScreen root = getPreferenceManager().createPreferenceScreen(this);
// category 1 created programmatically
PreferenceCategory cat1 = new PreferenceCategory(this);
cat1.setTitle("title");
root.addPreference(cat1);
ListPreference list1 = new ListPreference(this);
list1.setTitle(getResources().getString(R.string.some_string_title));
list1.setSummary(getResources().getString(R.string.some_string_text));
list1.setDialogTitle(getResources().getString(R.string.some_string_pick_title));
list1.setKey("your_key");
CharSequence[] entries = calendars.getCalenders(); //or anything else that returns the right data
list1.setEntries(entries);
int length = entries.length;
CharSequence[] values = new CharSequence[length];
for (int i=0; i<length; i++){
CharSequence val = ""+i+1+"";
values[i] = val;
}
list1.setEntryValues(values);
cat1.addPreference(list1);
return root;
}//end method

Stackoverflow error on android using scala parsers

How is it possible to get a stackoverflowerror using scala parsers in Android?
I was using this code:
val parseEApply: Parser[EApply] =
("EApply" ~> "(" ~> parseExpression) ~ ("," ~> parseListExpression <~ ")") ^^ {
case e ~ l => EApply(e, l)
}
By rewriting it using different parenthesis, I got rid of the error. Can someone explain me why ?
EApply is an expression that can contain other expressions, and a list of expressions.
val parseEApply: Parser[EApply] =
"EApply(" ~> parseExpression ~ ("," ~> parseListExpression <~ ")") ^^ {
case e ~ l => EApply(e, l)
}
So why there might be a recursion error in the first and not in the second?

I was able to partially solve the problem by regrouping parsers in pairs. So instead of:
val parseExpression = p1 | p2 | p3 | p4 | p5 | p6 | p7 | p8
I wrote it with parentheses
val parseExpression = ((p1 | p2) | (p3 | p4)) | ((p5 | p6) | (p7 | p8))
And it worked without complaints.

How to iterate through a joined table with multiple results?

I have 3 tables, USER, ENTRY (for entered products, not necessary to create a PRODUCT table), and USER_COLLECTION, which is a table inbetween USER and ENTRY, because an entry can have multiple users.
Basically:
User = USERID | USER_NAME
Entry = ENTRYID | ENTRY_NAME | ENTRYPRICE | ENTRY_DATE
Collection = COLLECTIONID | ENTRYID | USERID
I have a table with users that persist throughout the project. They can create entries (which is usually some kind of product with a price) and they can link multiple users to a certain entry (which can be selected from a list, hence the users persist throughout the project).
So for instance, my tables look like this:
User
--------------------------
user_id | user_name
--------------------------
1 | 'FOO'
2 | 'BAR'
3 | 'FOOBAR'
ENTRY
-----------------------------------------------------------------------
entryid | entry_name | entry_price | entry_date
-----------------------------------------------------------------------
0 | 'Banana' | 2.50 | 12/12/2012
COLLECTION
---------------------------------------
collectionid | entryid | userid
----------------------------------------
0 | 1 | 1
1 | 1 | 2
2 | 1 | 3
I have a Banana, with a price of 2.50 and 3 users linked to it, Foo, Bar and Foobar.
Now, I want to use this in my app and get the data; except I don't know where to start. I tried selecting the entry data, using that id to loop through the collection data, but that would mean I have two cursors open and it wouldn't work. Tried creating a join but I couldn't really make a good one, mainly because:
JOIN
---------------------------------------
collectionid | entryname | username
----------------------------------------
0 | Banana | FOO
1 | Banana | BAR
2 | Banana | FOOBAR
I can't iterate through this, because I would create multiple of the same entry objects in my Android code...
Hope I'm being clear on this.
if (cursor2.moveToFirst()) {
do {
Item i = new Item(<GET STUFF FROM CURSOR>);
i.addUser(new Person(<GET STUFF FROM CURSOR>)));
Log.d("TAG", i.getUsersPaying().size() + "");
} while (cursor2.moveToNext());
}
If I use this, I create mulitple instances of Item i. They'll all be Banana, whilst I should only have 1 item Banana, with multiple users added to it.

First, you might want to consider returning the IDs from your tables in your join query. Things would be a little easier if you returned the entryid column.
Just make a Map<Integer, Item> to store items that you have seen already in your loop. As you examine each cursor, check the map to see if you already have an instance. If you don't, just make a new one and insert it.
Let's assume your query results are:
JOIN
----------------------------------------------------
collectionid | entryname | entryname | username
----------------------------------------------------
0 | 1 | Banana | FOO
1 | 1 | Banana | BAR
2 | 1 | Banana | FOOBAR
2 | 2 | Apple | FOOBAR
You can modify your code as follows:
Map<Integer, Item> items = new HashMap<Integer, Item>();
if (cursor2.moveToFirst()) {
do {
int itemId = cursor2.getInt(1);
Item i;
if (items.containsKey(itemId))
i = items.get(itemId);
else
{
i = new Item(<GET STUFF FROM CURSOR>);
items.put(itemId, i);
}
i.addUser(new Person(<GET STUFF FROM CURSOR>)));
Log.d("TAG", i.getUsersPaying().size() + "");
} while (cursor2.moveToNext());
}

You need to maintain a dictionnary of your entities which are already loaded in memory. For instance in a background fragment which would be retained.
Basically you would do:
Item i = cacheFragment.createOrGetEntry( cursor.getLong( ENTRY_ID_COLUMN_INDEX ) );
Person p = cacheFragment.createOrGetPerson( cursor.getLong( PERSON_ID_COLUMN_INDEX ) );
Of course, your query must also return the IDs of all the rows you need (entryId and personId). But a join query is the way to do it efficiently, so keep what you did about that and just add the two missing ID columns.
a createOrGetPerson method would look like:
public Person createOrGetPerson(long id) {
Entry<Long, Person> p = personDictionnary.get( id ); // can be a HashMap or even better, a SparseArray
if (p==null) {
p = new Person(id);
personDictionnary.put(p); // Remember it for next time
}
return p;
}
You should also have a look at data persistence frameworks or ORM frameworks which are made to deal with this kind of problem (e.g. Hibernate, even though I don't know if that is working with Android).