SQLite helper secret example xddddd

RaffleSqliteDBHelper.kt

package com.dupla.dupla.db

import android.content.Context
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.util.Log


/**
 * Created by enzoftware on 4/20/18.
 */
class RaffleSqliteDBHelper(context: Context?, name:String = "" ,factory: SQLiteDatabase.CursorFactory?, version: Int) : SQLiteOpenHelper(context, name, factory, version) {
    override fun onCreate(db: SQLiteDatabase?) {
        val query = "CREATE TABLE $RAFFLE_TABLE_NAME ($RAFFLE_ID_COLUMN TEXT,$RAFFLE_NAME_COLUMN TEXT,$RAFFLE_SHOP_COLUMN TEXT,$RAFFLE_DATE_COLUMN TEXT, $RAFFLE_INIA_COLUMN TEXT, $RAFFLE_INIB_COLUMN TEXT)"
        db!!.execSQL(query)
        Log.i("SQLITEDB","CREATE SUCCESS")
    }

    override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
        db!!.execSQL("DROP TABLE IF EXISTS $RAFFLE_TABLE_NAME")
        onCreate(db)
    }

    companion object {
        var RAFFLE_TABLE_NAME : String = "Sorteos"
        var RAFFLE_ID_COLUMN : String = "key"
        var RAFFLE_NAME_COLUMN : String = "nombre"
        var RAFFLE_SHOP_COLUMN : String = "tienda"
        var RAFFLE_DATE_COLUMN : String = "fecha"
        var RAFFLE_INIA_COLUMN : String = "IniA"
        var RAFFLE_INIB_COLUMN : String = "IniB"
    }
}

utilsFunctions.kt

package com.dupla.dupla.utils

import android.app.Activity
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.database.sqlite.SQLiteDatabase
import android.net.Uri
import android.os.Environment
import android.util.Log
import android.widget.Toast
import com.dupla.dupla.db.RaffleSqliteDBHelper
import com.dupla.dupla.db.StockFinalSqliteDBHelper
import com.dupla.dupla.db.WinnerSqliteDBHelper
import com.dupla.dupla.model.RaffleInfo
import com.dupla.dupla.model.RaffleWinnerInfo
import com.dupla.dupla.model.StockFinalInfo
import com.dupla.dupla.model.Test
import com.google.firebase.database.DatabaseReference
import com.google.firebase.storage.StorageReference
import com.google.firebase.storage.UploadTask
import com.google.gson.Gson
import com.google.gson.GsonBuilder
import com.karumi.dexter.Dexter
import com.karumi.dexter.PermissionToken
import com.karumi.dexter.listener.PermissionDeniedResponse
import com.karumi.dexter.listener.PermissionGrantedResponse
import com.karumi.dexter.listener.PermissionRequest
import com.karumi.dexter.listener.single.PermissionListener
import java.io.BufferedWriter
import java.io.File
import java.io.FileWriter
import java.io.IOException
import java.text.SimpleDateFormat
import java.util.*


/**
 * Created by enzoftware on 4/10/18.
 */


var stockInicialTipoA:String? = null
var stockInicialTipoB:String? = null

var stockFinalTipoA:String? = null
var stockFinalTipoB:String? = null

var storageReference: StorageReference? = null
var mDatabase: DatabaseReference? = null
var FilePathUri: Uri? = null

lateinit var raffleId:String

var gson : Gson ?= null;

fun requestPermission(activity: Activity, permission: String){
    Dexter  .withActivity(activity)
            .withPermission(permission)
            .withListener(object : PermissionListener {
                override fun onPermissionGranted(response: PermissionGrantedResponse?) {
                    Log.i("Permission",response.toString())
                }

                override fun onPermissionRationaleShouldBeShown(permission: PermissionRequest?, token: PermissionToken?) {
                    Log.i("Permission",permission.toString())
                }

                override fun onPermissionDenied(response: PermissionDeniedResponse?) {
                    Log.i("Permission",response.toString())
                }
            }).check()
}


@Throws(InterruptedException::class, IOException::class)
fun isConnected(): Boolean {
    val command = "ping -c 1 google.com"
    return Runtime.getRuntime().exec(command).waitFor() == 0
}

fun uploadImageFileToFirebaseStorage(context: Context, rwi: RaffleWinnerInfo) {
    if (FilePathUri != null) {
        saveWinnerToDB(rwi,context)
    } else {
        Toast.makeText(context, "Please take a picture", Toast.LENGTH_LONG).show()
    }
}

fun getMoment():String = SimpleDateFormat("yyyyMMddHHmmssSSSS", Locale.ENGLISH).format(Date())

fun writeNewRaffle(context: Context){
    val ls = readRaffleFromDB(context)
    if(ls.size > 0){
        for (raffle in ls){
            val id = mDatabase!!.push().key
            mDatabase!!.child("Sorteos").child(id).setValue(raffle)
        }
    }
}

fun writeRaffleWinner(context: Context){
    val ls = readWinnerFromDB(context)
    lateinit var downloadUrl:String
    if(ls.size > 0){
        for (winner in ls){
           val file = Uri.fromFile(File(winner.imgFilePath))
            val riversRef = storageReference!!.child("images/${file.lastPathSegment}")
            val uploadTask: UploadTask = riversRef.putFile(file)
            uploadTask.addOnFailureListener({
                Log.i("error",it.message)
            }).addOnSuccessListener({ taskSnapshot ->
                Log.i("WinnerInfo",winner.toString())
                val id = mDatabase!!.push().key
                downloadUrl = taskSnapshot.downloadUrl.toString()
                Log.i("url",downloadUrl)
                winner.imgPremioUrl = downloadUrl
                val t = Test(winner.nombreGanador,winner.dniGanador,winner.emailGanador,winner.premiosA,winner.premiosB,winner.raffleKey,winner.id,downloadUrl)
                mDatabase!!.child("Ganadores").child(id).setValue(t)
            })
        }
    }
}

fun writeFinalStock(context: Context){
    val ls = readStockFromDB(context)
    if(ls.size > 0){
        for (stock in ls){
            val id = mDatabase!!.push().key
            mDatabase!!.child("Stocks").child(id).setValue(stock)
        }
    }
}


fun saveRaffleToDB(ri:RaffleInfo,context: Context){
    val db:SQLiteDatabase = RaffleSqliteDBHelper(context,"Sorteos",null,3).writableDatabase
    val values = ContentValues()
    raffleId = getMoment()
    values.apply {
        put(RaffleSqliteDBHelper.RAFFLE_ID_COLUMN, raffleId)
        put(RaffleSqliteDBHelper.RAFFLE_NAME_COLUMN, ri.nombreEncargado)
        put(RaffleSqliteDBHelper.RAFFLE_SHOP_COLUMN, ri.nombreTienda)
        put(RaffleSqliteDBHelper.RAFFLE_DATE_COLUMN, ri.fecha)
        put(RaffleSqliteDBHelper.RAFFLE_INIA_COLUMN, ri.inia)
        put(RaffleSqliteDBHelper.RAFFLE_INIB_COLUMN, ri.inib)
        db.insert(RaffleSqliteDBHelper.RAFFLE_TABLE_NAME,null,values)
        Log.i("dbWriteRaffle",values.toString())
    }
}

fun saveWinnerToDB(wi:RaffleWinnerInfo,context: Context){
    val db:SQLiteDatabase = WinnerSqliteDBHelper(context,"Ganadores",null,3).writableDatabase
    val values = ContentValues()
    values.apply {
        put(WinnerSqliteDBHelper.WINNER_ID_COLUMN, getMoment())
        put(WinnerSqliteDBHelper.WINNER_NAME_COLUMN, wi.nombreGanador)
        put(WinnerSqliteDBHelper.WINNER_DNI_COLUMN, wi.dniGanador)
        put(WinnerSqliteDBHelper.WINNER_EMAIL_COLUMN, wi.emailGanador)
        put(WinnerSqliteDBHelper.WINNER_PA_COLUMN, wi.premiosA)
        put(WinnerSqliteDBHelper.WINNER_PB_COLUMN, wi.premiosB)
        put(WinnerSqliteDBHelper.WINNER_URL_IMG_COLUMN, wi.imgPremioUrl)
        put(WinnerSqliteDBHelper.WINNER_PATH_IMG_COLUMN,wi.imgFilePath)
        put(WinnerSqliteDBHelper.WINNER_RAFFLE_KEY_COLUMN, raffleId)
        db.insert(WinnerSqliteDBHelper.WINNER_TABLE_NAME,null,values)
        Log.i("dbWriteWinner",values.toString())
    }
}

fun saveStockFinalToDB(sfi:StockFinalInfo,context: Context){
    val db:SQLiteDatabase = StockFinalSqliteDBHelper(context,"StockFinal",null,3).writableDatabase
    val values = ContentValues()
    values.apply {
        put(StockFinalSqliteDBHelper.SF_ID_COLUMN, getMoment())
        put(StockFinalSqliteDBHelper.SF_INIT_A_COLUMN,sfi.stockIniTipoA)
        put(StockFinalSqliteDBHelper.SF_INIT_B_COLUMN,sfi.stockIniTipoB)
        put(StockFinalSqliteDBHelper.SF_END_A_COLUMN,sfi.stockFinTipoA)
        put(StockFinalSqliteDBHelper.SF_END_B_COLUMN,sfi.stockFinTipoB)
        put(StockFinalSqliteDBHelper.SF_RAFFLE_KEY_COLUMN, raffleId)
        db.insert(StockFinalSqliteDBHelper.SF_TABLE_NAME,null,values)
        Log.i("dbWriteStock",values.toString())
    }
}

fun cleanDB(context: Context){
    val dbRaffle: SQLiteDatabase = RaffleSqliteDBHelper(context,"Sorteos",null, 3).writableDatabase
    val dbWinner: SQLiteDatabase = WinnerSqliteDBHelper(context,"Ganadores",null,3).writableDatabase
    val dbStockFinal: SQLiteDatabase = StockFinalSqliteDBHelper(context,"StockFinal",null,3).writableDatabase
    writeIntoFileAppend(context)
    dbRaffle.execSQL("DELETE FROM Sorteos")
    dbWinner.execSQL("DELETE FROM Ganadores")
    dbStockFinal.execSQL("DELETE FROM StockFinal")
    Log.i("eraseDB","se borro men")
}

fun readRaffleFromDB(context: Context): ArrayList<RaffleInfo>{
    val arrayRaffle: ArrayList<RaffleInfo> = ArrayList()
    val db: SQLiteDatabase = RaffleSqliteDBHelper(context, "Sorteos", null, 3).readableDatabase
    val cursor: Cursor = db.rawQuery("SELECT * FROM Sorteos",null)
    if (cursor.count != 0){
        cursor.moveToFirst()
        do{
            val idRaffle:String = cursor.getString(0)
            val encargado:String = cursor.getString(1)
            val tienda:String = cursor.getString(2)
            val fecha:String = cursor.getString(3)
            val inia: Int = cursor.getString(4).toInt()
            val inib: Int = cursor.getString(5).toInt()
            arrayRaffle.add(RaffleInfo(encargado,tienda,fecha,idRaffle, inia,inib))
        }while (cursor.moveToNext())
        cursor.close()
    }
    return arrayRaffle
}


fun readWinnerFromDB(context: Context): ArrayList<RaffleWinnerInfo>{
    val arrayWinner: ArrayList<RaffleWinnerInfo> = ArrayList()
    val db: SQLiteDatabase = WinnerSqliteDBHelper(context, "Ganadores", null, 3).readableDatabase
    val cursor: Cursor = db.rawQuery("SELECT * FROM ${WinnerSqliteDBHelper.WINNER_TABLE_NAME}",null)
    if (cursor.count != 0){
        cursor.moveToFirst()
        do{
            val idWinner:String = cursor.getString(0)
            val nombreGanador:String = cursor.getString(1)
            val dniGanador:String = cursor.getString(2)
            val emailGanador:String = cursor.getString(3)
            val tipoAGanador:Int = cursor.getInt(4)
            val tipoBGanador:Int = cursor.getInt(5)
            val url:String = cursor.getString(6)
            val path:String = cursor.getString(7)
            val raffleKey:String = cursor.getString(8)
            arrayWinner.add(RaffleWinnerInfo(nombreGanador,dniGanador,emailGanador,tipoAGanador,tipoBGanador,path,url,raffleKey,idWinner))
        }while (cursor.moveToNext())
        cursor.close()
    }
    return arrayWinner
}

fun readStockFromDB(context: Context): ArrayList<StockFinalInfo>{
    val arrayStock: ArrayList<StockFinalInfo> = ArrayList()
    val db: SQLiteDatabase = StockFinalSqliteDBHelper(context, "StockFinal", null, 3).readableDatabase
    val cursor: Cursor = db.rawQuery("SELECT * FROM StockFinal",null)
    if (cursor.count != 0){
        cursor.moveToFirst()
        do{
            val idStock:String = cursor.getString(0)
            val iniA:Int = cursor.getInt(1)
            val iniB:Int = cursor.getInt(2)
            val finA:Int = cursor.getInt(3)
            val finB:Int = cursor.getInt(4)
            val rafflekey:String = cursor.getString(5)
            arrayStock.add(StockFinalInfo(iniA,iniB,finA,finB,rafflekey,idStock))
        }while (cursor.moveToNext())
        cursor.close()
    }
    return arrayStock
}


fun writeIntoFileAppend(context: Context){
    gson = GsonBuilder().create()
    try {

        val contentCanje : String = gson!!.toJson(readWinnerFromDB(context))
        val contentStock : String = gson!!.toJson(readStockFromDB(context))
        val contentSorteo : String = gson!!.toJson(readRaffleFromDB(context))

        val contenidoTotal : String = "$contentCanje , $contentSorteo , $contentStock"

        val path = Environment.getExternalStoragePublicDirectory(
                    Environment.DIRECTORY_DOCUMENTS);
        val file = File(path,"basedatosDupla.txt")

        if (!file.exists()) {
            file.createNewFile()
        }

        val fw = FileWriter(file.absoluteFile,true)
        val bw = BufferedWriter(fw)
        bw.write(contenidoTotal)
        bw.close()
        Log.i("file",file.absolutePath)
    } catch (e: IOException) {
        e.printStackTrace()
    }

}