| 1 | efrain | 1 | //
 | 
        
           |  |  | 2 | //  ProgressDao.swift
 | 
        
           |  |  | 3 | //  twogetskills
 | 
        
           |  |  | 4 | //
 | 
        
           |  |  | 5 | //  Created by Efrain Yanez Recanatini on 2/21/22.
 | 
        
           |  |  | 6 | //
 | 
        
           |  |  | 7 |   | 
        
           | 17 | efrain | 8 | import SwiftUI
 | 
        
           | 1 | efrain | 9 | import SQLite3
 | 
        
           |  |  | 10 |   | 
        
           |  |  | 11 | class ProgressDao {
 | 
        
           | 17 | efrain | 12 |     private var database = Environment(\.database).wrappedValue
 | 
        
           | 1 | efrain | 13 |     private let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 | 
        
           | 17 | efrain | 14 |   | 
        
           |  |  | 15 |   | 
        
           | 1 | efrain | 16 |     func selectByTopicUuid(topicUuid: String)-> ProgressModel {
 | 
        
           | 17 | efrain | 17 |         let db = database.open()
 | 
        
           | 1 | efrain | 18 |         //var records = [ProgressModel]()
 | 
        
           |  |  | 19 |         var model = ProgressModel()
 | 
        
           |  |  | 20 |         var query = "SELECT "
 | 
        
           |  |  | 21 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ID + " , "
 | 
        
           |  |  | 22 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + " , "
 | 
        
           |  |  | 23 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " , "
 | 
        
           |  |  | 24 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " , "
 | 
        
           |  |  | 25 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " , "
 | 
        
           |  |  | 26 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " , "
 | 
        
           |  |  | 27 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " , "
 | 
        
           |  |  | 28 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " , "
 | 
        
           |  |  | 29 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " , "
 | 
        
           |  |  | 30 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + " , "
 | 
        
           |  |  | 31 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " , "
 | 
        
           |  |  | 32 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " , "
 | 
        
           |  |  | 33 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 34 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + " , "
 | 
        
           |  |  | 35 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON
 | 
        
           |  |  | 36 |         query = query +  " FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 37 |         query = query +  " WHERE " +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " = '\(topicUuid)'  "
 | 
        
           |  |  | 38 |         query = query +  " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + " = '\( Constants.PROGRESS_TYPE_TOPIC)' LIMIT 1 ;"
 | 
        
           |  |  | 39 |   | 
        
           |  |  | 40 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 41 |   | 
        
           |  |  | 42 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 43 |             if (sqlite3_step(statement) == SQLITE_ROW) {
 | 
        
           |  |  | 44 |                 model.id = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 45 |                 model.companyUuid = String(describing: String(cString: sqlite3_column_text(statement, 1)))
 | 
        
           |  |  | 46 |                 model.userUuid = String(describing: String(cString: sqlite3_column_text(statement, 2)))
 | 
        
           |  |  | 47 |                 model.topicUuid = String(describing: String(cString: sqlite3_column_text(statement, 3)))
 | 
        
           |  |  | 48 |                 model.capsuleUuid = String(describing: String(cString: sqlite3_column_text(statement, 4)))
 | 
        
           |  |  | 49 |                 model.slideUuid = String(describing: String(cString: sqlite3_column_text(statement,5)))
 | 
        
           |  |  | 50 |                 model.totalSlides = Int(sqlite3_column_int(statement, 6))
 | 
        
           |  |  | 51 |                 model.viewSlides = Int(sqlite3_column_int(statement, 7))
 | 
        
           |  |  | 52 |                 model.progress = Double(sqlite3_column_double(statement, 8))
 | 
        
           |  |  | 53 |                 model.type = String(describing: String(cString: sqlite3_column_text(statement, 9)))
 | 
        
           |  |  | 54 |                 model.returning = Int(sqlite3_column_int(statement, 10))
 | 
        
           |  |  | 55 |                 model.returningAfterCompleted = Int(sqlite3_column_int(statement, 11))
 | 
        
           |  |  | 56 |                 model.completed = Int(sqlite3_column_int(statement, 12))
 | 
        
           |  |  | 57 |                 model.addedOn = String(describing: String(cString: sqlite3_column_text(statement, 13)))
 | 
        
           |  |  | 58 |                 model.updatedOn = String(describing: String(cString: sqlite3_column_text(statement, 14)))
 | 
        
           |  |  | 59 |             }
 | 
        
           |  |  | 60 |         } else {
 | 
        
           | 15 | efrain | 61 |   | 
        
           | 1 | efrain | 62 |         }
 | 
        
           |  |  | 63 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 64 |         return model
 | 
        
           |  |  | 65 |     }
 | 
        
           |  |  | 66 |   | 
        
           |  |  | 67 |   | 
        
           |  |  | 68 |     func selectByTopicUuidAndUserUuid(topicUuid: String, userUuid : String)-> ProgressModel {
 | 
        
           | 17 | efrain | 69 |         let db = database.open()
 | 
        
           | 1 | efrain | 70 |         //var records = [ProgressModel]()
 | 
        
           |  |  | 71 |         var model = ProgressModel()
 | 
        
           |  |  | 72 |         var query = "SELECT "
 | 
        
           |  |  | 73 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ID + " , "
 | 
        
           |  |  | 74 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + " , "
 | 
        
           |  |  | 75 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " , "
 | 
        
           |  |  | 76 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " , "
 | 
        
           |  |  | 77 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " , "
 | 
        
           |  |  | 78 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " , "
 | 
        
           |  |  | 79 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " , "
 | 
        
           |  |  | 80 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " , "
 | 
        
           |  |  | 81 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " , "
 | 
        
           |  |  | 82 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + " , "
 | 
        
           |  |  | 83 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " , "
 | 
        
           |  |  | 84 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " , "
 | 
        
           |  |  | 85 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 86 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + " , "
 | 
        
           |  |  | 87 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON
 | 
        
           |  |  | 88 |         query = query +  " FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 89 |         query = query +  " WHERE " +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " = '\(topicUuid)'  "
 | 
        
           |  |  | 90 |         query = query +  " AND " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)'  "
 | 
        
           |  |  | 91 |         query = query +  " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + " = '\( Constants.PROGRESS_TYPE_TOPIC)' LIMIT 1 ;"
 | 
        
           |  |  | 92 |   | 
        
           |  |  | 93 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 94 |   | 
        
           |  |  | 95 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 96 |             if (sqlite3_step(statement) == SQLITE_ROW) {
 | 
        
           |  |  | 97 |                 model.id = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 98 |                 model.companyUuid = String(describing: String(cString: sqlite3_column_text(statement, 1)))
 | 
        
           |  |  | 99 |                 model.userUuid = String(describing: String(cString: sqlite3_column_text(statement, 2)))
 | 
        
           |  |  | 100 |                 model.topicUuid = String(describing: String(cString: sqlite3_column_text(statement, 3)))
 | 
        
           |  |  | 101 |                 model.capsuleUuid = String(describing: String(cString: sqlite3_column_text(statement, 4)))
 | 
        
           |  |  | 102 |                 model.slideUuid = String(describing: String(cString: sqlite3_column_text(statement,5)))
 | 
        
           |  |  | 103 |                 model.totalSlides = Int(sqlite3_column_int(statement, 6))
 | 
        
           |  |  | 104 |                 model.viewSlides = Int(sqlite3_column_int(statement, 7))
 | 
        
           |  |  | 105 |                 model.progress = Double(sqlite3_column_double(statement, 8))
 | 
        
           |  |  | 106 |                 model.type = String(describing: String(cString: sqlite3_column_text(statement, 9)))
 | 
        
           |  |  | 107 |                 model.returning = Int(sqlite3_column_int(statement, 10))
 | 
        
           |  |  | 108 |                 model.returningAfterCompleted = Int(sqlite3_column_int(statement, 11))
 | 
        
           |  |  | 109 |                 model.completed = Int(sqlite3_column_int(statement, 12))
 | 
        
           |  |  | 110 |                 model.addedOn = String(describing: String(cString: sqlite3_column_text(statement, 13)))
 | 
        
           |  |  | 111 |                 model.updatedOn = String(describing: String(cString: sqlite3_column_text(statement, 14)))
 | 
        
           |  |  | 112 |             }
 | 
        
           |  |  | 113 |         } else {
 | 
        
           | 15 | efrain | 114 |   | 
        
           | 1 | efrain | 115 |         }
 | 
        
           |  |  | 116 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 117 |         return model
 | 
        
           |  |  | 118 |     }
 | 
        
           |  |  | 119 |   | 
        
           |  |  | 120 |     func selectByCapsuleUuid(capsuleUuid: String)-> ProgressModel {
 | 
        
           | 17 | efrain | 121 |         let db = database.open()
 | 
        
           | 1 | efrain | 122 |         //var records = [ProgressModel]()
 | 
        
           |  |  | 123 |         var model = ProgressModel()
 | 
        
           |  |  | 124 |         var query = "SELECT "
 | 
        
           |  |  | 125 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ID + " , "
 | 
        
           |  |  | 126 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + " , "
 | 
        
           |  |  | 127 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " , "
 | 
        
           |  |  | 128 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " , "
 | 
        
           |  |  | 129 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " , "
 | 
        
           |  |  | 130 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " , "
 | 
        
           |  |  | 131 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " , "
 | 
        
           |  |  | 132 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " , "
 | 
        
           |  |  | 133 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " , "
 | 
        
           |  |  | 134 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + " , "
 | 
        
           |  |  | 135 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " , "
 | 
        
           |  |  | 136 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " , "
 | 
        
           |  |  | 137 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 138 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + " , "
 | 
        
           |  |  | 139 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON
 | 
        
           |  |  | 140 |         query = query +  " FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 141 |         query = query +  " WHERE " +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " = '\(capsuleUuid)'  "
 | 
        
           |  |  | 142 |         query = query +  " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + " = '\( Constants.PROGRESS_TYPE_CAPSULE)' LIMIT 1 ;"
 | 
        
           |  |  | 143 |   | 
        
           |  |  | 144 |   | 
        
           |  |  | 145 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 146 |   | 
        
           |  |  | 147 |   | 
        
           |  |  | 148 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 149 |             if (sqlite3_step(statement) == SQLITE_ROW) {
 | 
        
           |  |  | 150 |                 model.id = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 151 |                 model.companyUuid = String(describing: String(cString: sqlite3_column_text(statement, 1)))
 | 
        
           |  |  | 152 |                 model.userUuid = String(describing: String(cString: sqlite3_column_text(statement, 2)))
 | 
        
           |  |  | 153 |                 model.topicUuid = String(describing: String(cString: sqlite3_column_text(statement, 3)))
 | 
        
           |  |  | 154 |                 model.capsuleUuid = String(describing: String(cString: sqlite3_column_text(statement, 4)))
 | 
        
           |  |  | 155 |                 model.slideUuid = String(describing: String(cString: sqlite3_column_text(statement,5)))
 | 
        
           |  |  | 156 |                 model.totalSlides = Int(sqlite3_column_int(statement, 6))
 | 
        
           |  |  | 157 |                 model.viewSlides = Int(sqlite3_column_int(statement, 7))
 | 
        
           |  |  | 158 |                 model.progress = Double(sqlite3_column_double(statement, 8))
 | 
        
           |  |  | 159 |                 model.type = String(describing: String(cString: sqlite3_column_text(statement, 9)))
 | 
        
           |  |  | 160 |                 model.returning = Int(sqlite3_column_int(statement, 10))
 | 
        
           |  |  | 161 |                 model.returningAfterCompleted = Int(sqlite3_column_int(statement, 11))
 | 
        
           |  |  | 162 |                 model.completed = Int(sqlite3_column_int(statement, 12))
 | 
        
           |  |  | 163 |                 model.addedOn = String(describing: String(cString: sqlite3_column_text(statement, 13)))
 | 
        
           |  |  | 164 |                 model.updatedOn = String(describing: String(cString: sqlite3_column_text(statement, 14)))
 | 
        
           |  |  | 165 |   | 
        
           |  |  | 166 |             }
 | 
        
           |  |  | 167 |         } else {
 | 
        
           | 15 | efrain | 168 |   | 
        
           | 1 | efrain | 169 |         }
 | 
        
           |  |  | 170 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 171 |         return model
 | 
        
           |  |  | 172 |   | 
        
           |  |  | 173 |     }
 | 
        
           |  |  | 174 |   | 
        
           |  |  | 175 |     func selectByCapsuleUuidAndUserUuid(capsuleUuid: String, userUuid : String)-> ProgressModel {
 | 
        
           | 17 | efrain | 176 |         let db = database.open()
 | 
        
           | 1 | efrain | 177 |         //var records = [ProgressModel]()
 | 
        
           |  |  | 178 |         var model = ProgressModel()
 | 
        
           |  |  | 179 |         var query  = "SELECT "
 | 
        
           |  |  | 180 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ID + " , "
 | 
        
           |  |  | 181 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + " , "
 | 
        
           |  |  | 182 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " , "
 | 
        
           |  |  | 183 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " , "
 | 
        
           |  |  | 184 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " , "
 | 
        
           |  |  | 185 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " , "
 | 
        
           |  |  | 186 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " , "
 | 
        
           |  |  | 187 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " , "
 | 
        
           |  |  | 188 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " , "
 | 
        
           |  |  | 189 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + " , "
 | 
        
           |  |  | 190 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " , "
 | 
        
           |  |  | 191 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " , "
 | 
        
           |  |  | 192 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 193 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + " , "
 | 
        
           |  |  | 194 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON
 | 
        
           |  |  | 195 |         query = query +  " FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 196 |         query = query +  " WHERE " +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " = '\(capsuleUuid)'  "
 | 
        
           |  |  | 197 |         query = query +  " AND " + Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)' "
 | 
        
           |  |  | 198 |         query = query +  " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + " = '\( Constants.PROGRESS_TYPE_CAPSULE)' LIMIT 1 ;"
 | 
        
           |  |  | 199 |   | 
        
           |  |  | 200 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 201 |   | 
        
           |  |  | 202 |   | 
        
           |  |  | 203 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 204 |             if (sqlite3_step(statement) == SQLITE_ROW) {
 | 
        
           |  |  | 205 |                 model.id = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 206 |                 model.companyUuid = String(describing: String(cString: sqlite3_column_text(statement, 1)))
 | 
        
           |  |  | 207 |                 model.userUuid = String(describing: String(cString: sqlite3_column_text(statement, 2)))
 | 
        
           |  |  | 208 |                 model.topicUuid = String(describing: String(cString: sqlite3_column_text(statement, 3)))
 | 
        
           |  |  | 209 |                 model.capsuleUuid = String(describing: String(cString: sqlite3_column_text(statement, 4)))
 | 
        
           |  |  | 210 |                 model.slideUuid = String(describing: String(cString: sqlite3_column_text(statement,5)))
 | 
        
           |  |  | 211 |                 model.totalSlides = Int(sqlite3_column_int(statement, 6))
 | 
        
           |  |  | 212 |                 model.viewSlides = Int(sqlite3_column_int(statement, 7))
 | 
        
           |  |  | 213 |                 model.progress = Double(sqlite3_column_double(statement, 8))
 | 
        
           |  |  | 214 |                 model.type = String(describing: String(cString: sqlite3_column_text(statement, 9)))
 | 
        
           |  |  | 215 |                 model.returning = Int(sqlite3_column_int(statement, 10))
 | 
        
           |  |  | 216 |                 model.returningAfterCompleted = Int(sqlite3_column_int(statement, 11))
 | 
        
           |  |  | 217 |                 model.completed = Int(sqlite3_column_int(statement, 12))
 | 
        
           |  |  | 218 |                 model.addedOn = String(describing: String(cString: sqlite3_column_text(statement, 13)))
 | 
        
           |  |  | 219 |                 model.updatedOn = String(describing: String(cString: sqlite3_column_text(statement, 14)))
 | 
        
           |  |  | 220 |   | 
        
           |  |  | 221 |             }
 | 
        
           |  |  | 222 |         } else {
 | 
        
           | 15 | efrain | 223 |   | 
        
           | 1 | efrain | 224 |         }
 | 
        
           |  |  | 225 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 226 |         return model
 | 
        
           |  |  | 227 |   | 
        
           |  |  | 228 |     }
 | 
        
           |  |  | 229 |   | 
        
           |  |  | 230 |     func selectBySlideUuid(slideUuid: String)-> ProgressModel {
 | 
        
           | 17 | efrain | 231 |         let db = database.open()
 | 
        
           | 1 | efrain | 232 |         //var records = [ProgressModel]()
 | 
        
           |  |  | 233 |         var model = ProgressModel()
 | 
        
           |  |  | 234 |         var query = "SELECT "
 | 
        
           |  |  | 235 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ID + " , "
 | 
        
           |  |  | 236 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + " , "
 | 
        
           |  |  | 237 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " , "
 | 
        
           |  |  | 238 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " , "
 | 
        
           |  |  | 239 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " , "
 | 
        
           |  |  | 240 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " , "
 | 
        
           |  |  | 241 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " , "
 | 
        
           |  |  | 242 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " , "
 | 
        
           |  |  | 243 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " , "
 | 
        
           |  |  | 244 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + " , "
 | 
        
           |  |  | 245 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " , "
 | 
        
           |  |  | 246 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " , "
 | 
        
           |  |  | 247 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 248 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + " , "
 | 
        
           |  |  | 249 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON
 | 
        
           |  |  | 250 |         query = query + " FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 251 |         query = query  + " WHERE " +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " = '\(slideUuid)'  "
 | 
        
           |  |  | 252 |         query = query  + " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + " = '\( Constants.PROGRESS_TYPE_SLIDE)' LIMIT 1 ;"
 | 
        
           |  |  | 253 |   | 
        
           |  |  | 254 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 255 |   | 
        
           |  |  | 256 |   | 
        
           |  |  | 257 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 258 |             if (sqlite3_step(statement) == SQLITE_ROW) {
 | 
        
           |  |  | 259 |                 model.id = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 260 |                 model.companyUuid = String(describing: String(cString: sqlite3_column_text(statement, 1)))
 | 
        
           |  |  | 261 |                 model.userUuid = String(describing: String(cString: sqlite3_column_text(statement, 2)))
 | 
        
           |  |  | 262 |                 model.topicUuid = String(describing: String(cString: sqlite3_column_text(statement, 3)))
 | 
        
           |  |  | 263 |                 model.capsuleUuid = String(describing: String(cString: sqlite3_column_text(statement, 4)))
 | 
        
           |  |  | 264 |                 model.slideUuid = String(describing: String(cString: sqlite3_column_text(statement,5)))
 | 
        
           |  |  | 265 |                 model.totalSlides = Int(sqlite3_column_int(statement, 6))
 | 
        
           |  |  | 266 |                 model.viewSlides = Int(sqlite3_column_int(statement, 7))
 | 
        
           |  |  | 267 |                 model.progress = Double(sqlite3_column_double(statement, 8))
 | 
        
           |  |  | 268 |                 model.type = String(describing: String(cString: sqlite3_column_text(statement, 9)))
 | 
        
           |  |  | 269 |                 model.returning = Int(sqlite3_column_int(statement, 10))
 | 
        
           |  |  | 270 |                 model.returningAfterCompleted = Int(sqlite3_column_int(statement, 11))
 | 
        
           |  |  | 271 |                 model.completed = Int(sqlite3_column_int(statement, 12))
 | 
        
           |  |  | 272 |                 model.addedOn = String(describing: String(cString: sqlite3_column_text(statement, 13)))
 | 
        
           |  |  | 273 |                 model.updatedOn = String(describing: String(cString: sqlite3_column_text(statement, 14)))
 | 
        
           |  |  | 274 |             }
 | 
        
           |  |  | 275 |         } else {
 | 
        
           | 15 | efrain | 276 |   | 
        
           | 1 | efrain | 277 |         }
 | 
        
           |  |  | 278 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 279 |         return model
 | 
        
           |  |  | 280 |     }
 | 
        
           |  |  | 281 |   | 
        
           |  |  | 282 |   | 
        
           |  |  | 283 |     func selectBySlideUuidAndUserUuid(slideUuid: String, userUuid : String)-> ProgressModel {
 | 
        
           | 17 | efrain | 284 |         let db = database.open()
 | 
        
           | 1 | efrain | 285 |         //var records = [ProgressModel]()
 | 
        
           |  |  | 286 |         var model = ProgressModel()
 | 
        
           |  |  | 287 |         var query = "SELECT "
 | 
        
           |  |  | 288 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ID + " , "
 | 
        
           |  |  | 289 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + " , "
 | 
        
           |  |  | 290 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " , "
 | 
        
           |  |  | 291 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " , "
 | 
        
           |  |  | 292 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " , "
 | 
        
           |  |  | 293 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " , "
 | 
        
           |  |  | 294 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " , "
 | 
        
           |  |  | 295 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " , "
 | 
        
           |  |  | 296 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " , "
 | 
        
           |  |  | 297 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + " , "
 | 
        
           |  |  | 298 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " , "
 | 
        
           |  |  | 299 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " , "
 | 
        
           |  |  | 300 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 301 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + " , "
 | 
        
           |  |  | 302 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON
 | 
        
           |  |  | 303 |         query = query + " FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 304 |         query = query  + " WHERE " +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + " = '\(slideUuid)'  "
 | 
        
           |  |  | 305 |         query = query  + " AND " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)'  "
 | 
        
           |  |  | 306 |         query = query  + " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + " = '\( Constants.PROGRESS_TYPE_SLIDE)' LIMIT 1 ;"
 | 
        
           |  |  | 307 |   | 
        
           |  |  | 308 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 309 |   | 
        
           |  |  | 310 |   | 
        
           |  |  | 311 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 312 |             if (sqlite3_step(statement) == SQLITE_ROW) {
 | 
        
           |  |  | 313 |                 model.id = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 314 |                 model.companyUuid = String(describing: String(cString: sqlite3_column_text(statement, 1)))
 | 
        
           |  |  | 315 |                 model.userUuid = String(describing: String(cString: sqlite3_column_text(statement, 2)))
 | 
        
           |  |  | 316 |                 model.topicUuid = String(describing: String(cString: sqlite3_column_text(statement, 3)))
 | 
        
           |  |  | 317 |                 model.capsuleUuid = String(describing: String(cString: sqlite3_column_text(statement, 4)))
 | 
        
           |  |  | 318 |                 model.slideUuid = String(describing: String(cString: sqlite3_column_text(statement,5)))
 | 
        
           |  |  | 319 |                 model.totalSlides = Int(sqlite3_column_int(statement, 6))
 | 
        
           |  |  | 320 |                 model.viewSlides = Int(sqlite3_column_int(statement, 7))
 | 
        
           |  |  | 321 |                 model.progress = Double(sqlite3_column_double(statement, 8))
 | 
        
           |  |  | 322 |                 model.type = String(describing: String(cString: sqlite3_column_text(statement, 9)))
 | 
        
           |  |  | 323 |                 model.returning = Int(sqlite3_column_int(statement, 10))
 | 
        
           |  |  | 324 |                 model.returningAfterCompleted = Int(sqlite3_column_int(statement, 11))
 | 
        
           |  |  | 325 |                 model.completed = Int(sqlite3_column_int(statement, 12))
 | 
        
           |  |  | 326 |                 model.addedOn = String(describing: String(cString: sqlite3_column_text(statement, 13)))
 | 
        
           |  |  | 327 |                 model.updatedOn = String(describing: String(cString: sqlite3_column_text(statement, 14)))
 | 
        
           |  |  | 328 |             }
 | 
        
           |  |  | 329 |         } else {
 | 
        
           | 15 | efrain | 330 |   | 
        
           | 1 | efrain | 331 |         }
 | 
        
           |  |  | 332 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 333 |         return model
 | 
        
           |  |  | 334 |     }
 | 
        
           |  |  | 335 |   | 
        
           |  |  | 336 |     func getCountSlideCompletedByCapsuleUuidAndUserUuid(capsuleUuid: String, userUuid: String) -> Int {
 | 
        
           | 17 | efrain | 337 |         let db = database.open()
 | 
        
           | 1 | efrain | 338 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS +
 | 
        
           |  |  | 339 |         " WHERE " +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + " = '\(capsuleUuid)' "  +
 | 
        
           |  |  | 340 |         " AND " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + "= '\(userUuid)'" +
 | 
        
           |  |  | 341 |         " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\(Constants.PROGRESS_TYPE_SLIDE)'" +
 | 
        
           |  |  | 342 |         " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "  =  1 "
 | 
        
           |  |  | 343 |   | 
        
           |  |  | 344 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 345 |         var count = 0;
 | 
        
           |  |  | 346 |   | 
        
           |  |  | 347 |   | 
        
           |  |  | 348 |   | 
        
           |  |  | 349 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 350 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 351 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 352 |   | 
        
           |  |  | 353 |             }
 | 
        
           |  |  | 354 |         } else {
 | 
        
           | 15 | efrain | 355 |   | 
        
           | 1 | efrain | 356 |         }
 | 
        
           |  |  | 357 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 358 |         return count;
 | 
        
           |  |  | 359 |     }
 | 
        
           |  |  | 360 |   | 
        
           |  |  | 361 |     func getCountSlideCompletedByTopicUuidAndUserUuid(topicUuid: String, userUuid: String) -> Int {
 | 
        
           | 17 | efrain | 362 |         let db = database.open()
 | 
        
           | 1 | efrain | 363 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS +
 | 
        
           |  |  | 364 |         " WHERE " +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " = '\(topicUuid)' "  +
 | 
        
           |  |  | 365 |         " AND " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + "= '\(userUuid)'" +
 | 
        
           |  |  | 366 |         " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\(Constants.PROGRESS_TYPE_SLIDE)'" +
 | 
        
           |  |  | 367 |         " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "  =  1 "
 | 
        
           |  |  | 368 |   | 
        
           |  |  | 369 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 370 |         var count = 0;
 | 
        
           |  |  | 371 |   | 
        
           |  |  | 372 |   | 
        
           |  |  | 373 |   | 
        
           |  |  | 374 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 375 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 376 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 377 |   | 
        
           |  |  | 378 |             }
 | 
        
           |  |  | 379 |         } else {
 | 
        
           | 15 | efrain | 380 |   | 
        
           | 1 | efrain | 381 |         }
 | 
        
           |  |  | 382 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 383 |         return count;
 | 
        
           |  |  | 384 |     }
 | 
        
           |  |  | 385 |   | 
        
           |  |  | 386 |     func getCountCapsulesCompletedByUserUuid(userUuid : String) -> Int {
 | 
        
           | 17 | efrain | 387 |         let db = database.open()
 | 
        
           | 1 | efrain | 388 |         var count = 0
 | 
        
           |  |  | 389 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS +
 | 
        
           |  |  | 390 |             " WHERE " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)' " +
 | 
        
           |  |  | 391 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 392 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 1 LIMIT 1"
 | 
        
           |  |  | 393 |   | 
        
           |  |  | 394 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 395 |   | 
        
           |  |  | 396 |   | 
        
           |  |  | 397 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 398 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 399 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 400 |                 //print("\(count)")
 | 
        
           |  |  | 401 |             }
 | 
        
           |  |  | 402 |         } else {
 | 
        
           | 15 | efrain | 403 |   | 
        
           | 1 | efrain | 404 |         }
 | 
        
           |  |  | 405 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 406 |         return count
 | 
        
           |  |  | 407 |     }
 | 
        
           |  |  | 408 |   | 
        
           |  |  | 409 |     func getCountCapsulesIncompletedByUserUuid(userUuid : String) -> Int {
 | 
        
           | 17 | efrain | 410 |         let db = database.open()
 | 
        
           | 1 | efrain | 411 |         var count = 0
 | 
        
           |  |  | 412 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS +
 | 
        
           |  |  | 413 |             " WHERE " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)' " +
 | 
        
           |  |  | 414 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 415 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 0 LIMIT 1"
 | 
        
           |  |  | 416 |   | 
        
           |  |  | 417 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 418 |   | 
        
           |  |  | 419 |   | 
        
           |  |  | 420 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 421 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 422 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 423 |                 //print("\(count)")
 | 
        
           |  |  | 424 |             }
 | 
        
           |  |  | 425 |         } else {
 | 
        
           | 15 | efrain | 426 |   | 
        
           | 1 | efrain | 427 |         }
 | 
        
           |  |  | 428 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 429 |         return count
 | 
        
           |  |  | 430 |     }
 | 
        
           |  |  | 431 |   | 
        
           |  |  | 432 |     func getCountCapsulesCompletedByTopicUuid(topicUuid : String) -> Int {
 | 
        
           | 17 | efrain | 433 |         let db = database.open()
 | 
        
           | 1 | efrain | 434 |         var count = 0
 | 
        
           |  |  | 435 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS +
 | 
        
           |  |  | 436 |             " WHERE " +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " = '\(topicUuid)' " +
 | 
        
           |  |  | 437 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 438 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 1 LIMIT 1"
 | 
        
           |  |  | 439 |   | 
        
           |  |  | 440 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 441 |   | 
        
           |  |  | 442 |   | 
        
           |  |  | 443 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 444 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 445 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 446 |                 //print("\(count)")
 | 
        
           |  |  | 447 |             }
 | 
        
           |  |  | 448 |         } else {
 | 
        
           | 15 | efrain | 449 |   | 
        
           | 1 | efrain | 450 |         }
 | 
        
           |  |  | 451 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 452 |         return count
 | 
        
           |  |  | 453 |     }
 | 
        
           |  |  | 454 |   | 
        
           |  |  | 455 |     func getCountCapsulesCompletedWithReturningByUserUuid(userUuid : String) -> Int {
 | 
        
           | 17 | efrain | 456 |         let db = database.open()
 | 
        
           | 1 | efrain | 457 |         var count = 0
 | 
        
           |  |  | 458 |         let query = "SELECT SUM(" +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + ") AS total FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 459 |             + " WHERE " +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)' " +
 | 
        
           |  |  | 460 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 461 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 1 " +
 | 
        
           |  |  | 462 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " > 0 LIMIT 1"
 | 
        
           |  |  | 463 |   | 
        
           |  |  | 464 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 465 |   | 
        
           |  |  | 466 |   | 
        
           |  |  | 467 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 468 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 469 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 470 |                 //print("\(count)")
 | 
        
           |  |  | 471 |             }
 | 
        
           |  |  | 472 |         } else {
 | 
        
           | 15 | efrain | 473 |   | 
        
           | 1 | efrain | 474 |         }
 | 
        
           |  |  | 475 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 476 |         return count
 | 
        
           |  |  | 477 |     }
 | 
        
           |  |  | 478 |   | 
        
           |  |  | 479 |     func getCountCapsulesCompletedWithoutReturningByUserUuid(userUuid : String) -> Int {
 | 
        
           | 17 | efrain | 480 |         let db = database.open()
 | 
        
           | 1 | efrain | 481 |         var count = 0
 | 
        
           |  |  | 482 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS + " WHERE "
 | 
        
           |  |  | 483 |             +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + " = '\(userUuid)' " +
 | 
        
           |  |  | 484 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 485 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 1 " +
 | 
        
           |  |  | 486 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " = 0 LIMIT 1"
 | 
        
           |  |  | 487 |   | 
        
           |  |  | 488 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 489 |   | 
        
           |  |  | 490 |   | 
        
           |  |  | 491 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 492 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 493 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 494 |                 //print("\(count)")
 | 
        
           |  |  | 495 |             }
 | 
        
           |  |  | 496 |         } else {
 | 
        
           | 15 | efrain | 497 |   | 
        
           | 1 | efrain | 498 |         }
 | 
        
           |  |  | 499 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 500 |         return count
 | 
        
           |  |  | 501 |     }
 | 
        
           |  |  | 502 |   | 
        
           |  |  | 503 |     func getCountCapsulesCompletedWithReturningByTopicUuid(topicUuid : String) -> Int {
 | 
        
           | 17 | efrain | 504 |         let db = database.open()
 | 
        
           | 1 | efrain | 505 |         var count = 0
 | 
        
           |  |  | 506 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 507 |             + " WHERE " +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " = '\(topicUuid)' " +
 | 
        
           |  |  | 508 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 509 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 1 " +
 | 
        
           |  |  | 510 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " > 0 LIMIT 1"
 | 
        
           |  |  | 511 |   | 
        
           |  |  | 512 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 513 |   | 
        
           |  |  | 514 |   | 
        
           |  |  | 515 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 516 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 517 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 518 |                 //print("\(count)")
 | 
        
           |  |  | 519 |             }
 | 
        
           |  |  | 520 |         } else {
 | 
        
           | 15 | efrain | 521 |   | 
        
           | 1 | efrain | 522 |         }
 | 
        
           |  |  | 523 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 524 |         return count
 | 
        
           |  |  | 525 |     }
 | 
        
           |  |  | 526 |   | 
        
           |  |  | 527 |     func getCountCapsulesCompletedWithoutReturningByTopicUuid(topicUuid : String) -> Int {
 | 
        
           | 17 | efrain | 528 |         let db = database.open()
 | 
        
           | 1 | efrain | 529 |         var count = 0
 | 
        
           |  |  | 530 |         let query = "SELECT COUNT(*) AS total FROM " +  Constants.TABLE_PROGRESS + " WHERE "
 | 
        
           |  |  | 531 |             +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID + " = '\(topicUuid)' " +
 | 
        
           |  |  | 532 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_TYPE + "= '\( Constants.PROGRESS_TYPE_CAPSULE)' " +
 | 
        
           |  |  | 533 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + "= 1 " +
 | 
        
           |  |  | 534 |             " AND " +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " = 0 LIMIT 1"
 | 
        
           |  |  | 535 |   | 
        
           |  |  | 536 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 537 |   | 
        
           |  |  | 538 |   | 
        
           |  |  | 539 |         if (sqlite3_prepare(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 540 |             if(sqlite3_step(statement) == SQLITE_ROW){
 | 
        
           |  |  | 541 |                 count = Int(sqlite3_column_int(statement, 0))
 | 
        
           |  |  | 542 |                 //print("\(count)")
 | 
        
           |  |  | 543 |             }
 | 
        
           |  |  | 544 |         } else {
 | 
        
           | 15 | efrain | 545 |   | 
        
           | 1 | efrain | 546 |         }
 | 
        
           |  |  | 547 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 548 |         return count
 | 
        
           |  |  | 549 |     }
 | 
        
           |  |  | 550 |   | 
        
           |  |  | 551 |   | 
        
           |  |  | 552 |     func insert( record : ProgressModel) {
 | 
        
           | 17 | efrain | 553 |         let db = database.open()
 | 
        
           | 1 | efrain | 554 |         var query = "INSERT INTO " +  Constants.TABLE_PROGRESS + " ( "
 | 
        
           |  |  | 555 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPANY_UUID + ", "
 | 
        
           |  |  | 556 |         query = query +  Constants.TABLE_PROGRESS_FIELD_USER_UUID + ", "
 | 
        
           |  |  | 557 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOPIC_UUID  + ", "
 | 
        
           |  |  | 558 |         query = query +  Constants.TABLE_PROGRESS_FIELD_CAPSULE_UUID + ", "
 | 
        
           |  |  | 559 |         query = query +  Constants.TABLE_PROGRESS_FIELD_SLIDE_UUID + ", "
 | 
        
           |  |  | 560 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + ", "
 | 
        
           |  |  | 561 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + ", "
 | 
        
           |  |  | 562 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + ", "
 | 
        
           |  |  | 563 |         query = query +  Constants.TABLE_PROGRESS_FIELD_TYPE + ", "
 | 
        
           |  |  | 564 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + ", "
 | 
        
           |  |  | 565 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + ", "
 | 
        
           |  |  | 566 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " , "
 | 
        
           |  |  | 567 |         query = query +  Constants.TABLE_PROGRESS_FIELD_ADDED_ON + ", "
 | 
        
           |  |  | 568 |         query = query +  Constants.TABLE_PROGRESS_FIELD_UPDATED_ON + " )"
 | 
        
           |  |  | 569 |   | 
        
           |  |  | 570 |         query = query + " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
 | 
        
           |  |  | 571 |         var statement : OpaquePointer?
 | 
        
           |  |  | 572 |   | 
        
           |  |  | 573 |   | 
        
           |  |  | 574 |         if sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK {
 | 
        
           |  |  | 575 |   | 
        
           |  |  | 576 |             sqlite3_bind_text(statement, 1, record.companyUuid, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 577 |             sqlite3_bind_text(statement, 2, record.userUuid, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 578 |             sqlite3_bind_text(statement, 3, record.topicUuid, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 579 |             sqlite3_bind_text(statement, 4, record.capsuleUuid, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 580 |             sqlite3_bind_text(statement, 5, record.slideUuid, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 581 |             sqlite3_bind_int(statement, 6, Int32(record.totalSlides))
 | 
        
           |  |  | 582 |             sqlite3_bind_int(statement, 7, Int32(record.viewSlides))
 | 
        
           |  |  | 583 |             sqlite3_bind_double(statement, 8, Double(record.progress))
 | 
        
           |  |  | 584 |             sqlite3_bind_text(statement, 9, record.type , -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 585 |             sqlite3_bind_int(statement, 10, Int32(record.returning))
 | 
        
           |  |  | 586 |             sqlite3_bind_int(statement, 11, Int32(record.returningAfterCompleted))
 | 
        
           |  |  | 587 |             sqlite3_bind_int(statement, 12, Int32(record.completed))
 | 
        
           |  |  | 588 |             sqlite3_bind_text(statement, 13, record.addedOn, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 589 |             sqlite3_bind_text(statement, 14, record.updatedOn, -1, SQLITE_TRANSIENT)
 | 
        
           |  |  | 590 |   | 
        
           |  |  | 591 |            if sqlite3_step(statement) != SQLITE_DONE {
 | 
        
           |  |  | 592 |                 print("No se pudo insertar un registro en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           |  |  | 593 |   | 
        
           | 15 | efrain | 594 |   | 
        
           | 1 | efrain | 595 |            } else {
 | 
        
           |  |  | 596 |              print("insertamos un registro de progreso")
 | 
        
           |  |  | 597 |            }
 | 
        
           |  |  | 598 |         } else {
 | 
        
           |  |  | 599 |             print("No se pudo preparar insertar un registro en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 600 |   | 
        
           | 1 | efrain | 601 |         }
 | 
        
           |  |  | 602 |   | 
        
           |  |  | 603 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 604 |     }
 | 
        
           |  |  | 605 |   | 
        
           |  |  | 606 |     func update(record : ProgressModel) {
 | 
        
           | 17 | efrain | 607 |         let db = database.open()
 | 
        
           | 1 | efrain | 608 |         var query = "UPDATE " +  Constants.TABLE_PROGRESS
 | 
        
           |  |  | 609 |         query = query + " SET " +  Constants.TABLE_PROGRESS_FIELD_TOTAL_SLIDES + " = '\(record.totalSlides)', "
 | 
        
           |  |  | 610 |         query = query +  Constants.TABLE_PROGRESS_FIELD_VIEW_SLIDES + " = '\(record.viewSlides)', "
 | 
        
           |  |  | 611 |         query = query +  Constants.TABLE_PROGRESS_FIELD_PROGRESS + " = '\(record.progress)', "
 | 
        
           |  |  | 612 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING + " = '\(record.returning)', "
 | 
        
           |  |  | 613 |         query = query +  Constants.TABLE_PROGRESS_FIELD_RETURNING_AFTER_COMPLETED + " = '\(record.returningAfterCompleted)', "
 | 
        
           |  |  | 614 |         query = query +  Constants.TABLE_PROGRESS_FIELD_COMPLETED + " = '\(record.completed)' "
 | 
        
           |  |  | 615 |         query = query + " WHERE " +  Constants.TABLE_PROGRESS_FIELD_ID + " = \(record.id);"
 | 
        
           |  |  | 616 |   | 
        
           |  |  | 617 |         //print("capsuleUpdate : \(query)")
 | 
        
           |  |  | 618 |   | 
        
           |  |  | 619 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 620 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 621 |             if sqlite3_step(statement) != SQLITE_DONE {
 | 
        
           |  |  | 622 |                 print("No se pudo actualizar un registro en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 623 |   | 
        
           | 1 | efrain | 624 |             }
 | 
        
           |  |  | 625 |         } else {
 | 
        
           |  |  | 626 |             print("Fallo la preparación de actualizar un registro en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 627 |   | 
        
           | 1 | efrain | 628 |         }
 | 
        
           |  |  | 629 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 630 |     }
 | 
        
           |  |  | 631 |   | 
        
           |  |  | 632 |     func remove(id: Int) {
 | 
        
           | 17 | efrain | 633 |         let db = database.open()
 | 
        
           | 1 | efrain | 634 |         let query = "DELETE FROM " +  Constants.TABLE_PROGRESS + " WHERE " +  Constants.TABLE_PROGRESS_FIELD_ID + " = " + "\(id) ;"
 | 
        
           |  |  | 635 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 636 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 637 |             if sqlite3_step(statement) != SQLITE_DONE {
 | 
        
           |  |  | 638 |                 print("No se pudo borrar un registro con el id: \(id) en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 639 |   | 
        
           | 1 | efrain | 640 |             }
 | 
        
           |  |  | 641 |         } else {
 | 
        
           |  |  | 642 |             print("Fallo la preparación de borrar un registro con el id: \(id) en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 643 |   | 
        
           | 1 | efrain | 644 |         }
 | 
        
           |  |  | 645 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 646 |     }
 | 
        
           |  |  | 647 |   | 
        
           |  |  | 648 |     func removeAll() {
 | 
        
           | 17 | efrain | 649 |         let db = database.open()
 | 
        
           | 1 | efrain | 650 |         let query = "DELETE FROM " +  Constants.TABLE_PROGRESS + ";"
 | 
        
           |  |  | 651 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 652 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 653 |             if sqlite3_step(statement) != SQLITE_DONE {
 | 
        
           |  |  | 654 |                 print("No se pudo borrar todos los registros en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 655 |   | 
        
           | 1 | efrain | 656 |             }
 | 
        
           |  |  | 657 |         } else {
 | 
        
           |  |  | 658 |             print("Fallo la preparación de borrar todos los registros en la tabla: \(Constants.TABLE_PROGRESS)")
 | 
        
           | 15 | efrain | 659 |   | 
        
           | 1 | efrain | 660 |         }
 | 
        
           |  |  | 661 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 662 |     }
 | 
        
           |  |  | 663 |   | 
        
           |  |  | 664 |     func removeAllUserUuidNotEqual(userUuid : String)
 | 
        
           |  |  | 665 |     {
 | 
        
           | 17 | efrain | 666 |         let db = database.open()
 | 
        
           | 1 | efrain | 667 |         let query = "DELETE FROM " +  Constants.TABLE_PROGRESS +
 | 
        
           |  |  | 668 |             " WHERE " + Constants.TABLE_PROGRESS_FIELD_USER_UUID + " <> '\(userUuid)' ;"
 | 
        
           |  |  | 669 |         var statement : OpaquePointer? = nil
 | 
        
           |  |  | 670 |         if (sqlite3_prepare_v2(db, query, -1, &statement, nil) == SQLITE_OK) {
 | 
        
           |  |  | 671 |             if sqlite3_step(statement) != SQLITE_DONE {
 | 
        
           |  |  | 672 |                 print("No se pudo borrar todos los registros en la tabla: \(Constants.TABLE_PROGRESS)" +
 | 
        
           |  |  | 673 |                 " de los usuarios diferentes de : \(userUuid)" )
 | 
        
           | 15 | efrain | 674 |   | 
        
           | 1 | efrain | 675 |             }
 | 
        
           |  |  | 676 |         } else {
 | 
        
           |  |  | 677 |             print("Fallo la preparación de borrar todos los registros en la tabla: \(Constants.TABLE_PROGRESS) de los usuarios diferentes de : \(userUuid) ")
 | 
        
           | 15 | efrain | 678 |   | 
        
           | 1 | efrain | 679 |         }
 | 
        
           |  |  | 680 |         sqlite3_finalize(statement)
 | 
        
           |  |  | 681 |     }
 | 
        
           |  |  | 682 |   | 
        
           |  |  | 683 | }
 |