Proyectos de Subversion Iphone Microlearning - Inconcert

Rev

Rev 2 | Rev 17 | Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log | 

//
//  DataService.swift
//  twogetskills
//
//  Created by Efrain Yanez Recanatini on 2/27/22.
//

import Foundation
import SwiftyJSON

class DataService
{
    private let database = Database.sharedInstance
    private var appData = AppData.sharedInstance

    
    
    func complete(topicModel : TopicModel, capsuleModel : CapsuleModel)
    {
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)
        

        let userUuid = appData.userUuid
        var json : [String: Any]
        var sync : SyncModel
        var userLog : UserLogModel

        let db = database.open()
        
        
        let syncDao = SyncDao(db : db)
        let progressDao = ProgressDao(db : db)
        let userLogDao = UserLogDao(db : db)
            
        var progressCapsule = progressDao.selectByCapsuleUuidAndUserUuid(capsuleUuid: capsuleModel.uuid, userUuid: userUuid)
        
        if progressCapsule.id > 0 && progressCapsule.progress >= 100 {
            progressCapsule.completed = 1
            progressCapsule.updatedOn = dateOn
            progressDao.update(record: progressCapsule)
            
            json = progressCapsule.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS
                        
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
               let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                      
            syncDao.insert(record : sync);
            
            userLog = UserLogModel()
            userLog.userUuid = userUuid
            userLog.companyUuid = topicModel.companyUuid
            userLog.topicUuid = topicModel.uuid
            userLog.capsuleUuid = capsuleModel.uuid
            userLog.activity = Constants.USER_LOG_ACTIVITY_COMPLETED_CAPSULE
            userLog.addedOn = dateOn
            userLogDao.insert(record: userLog)
            
            json = userLog.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG
                    
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
                let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                      
            syncDao.insert(record : sync);
        }

        var progressTopic = progressDao.selectByTopicUuidAndUserUuid(topicUuid: topicModel.uuid, userUuid: userUuid)
        
        if progressTopic.id > 0 && progressTopic.progress >= 100 {
            progressTopic.completed = 1
            progressTopic.updatedOn = dateOn
            progressDao.update(record: progressTopic)

            json = progressTopic.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS
                        
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
               let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                      
            syncDao.insert(record : sync);
            
            userLog = UserLogModel()
            userLog.userUuid = userUuid
            userLog.companyUuid = topicModel.companyUuid
            userLog.topicUuid = topicModel.uuid
            userLog.activity = Constants.USER_LOG_ACTIVITY_COMPLETED_TOPIC
            userLog.addedOn = dateOn
            userLogDao.insert(record: userLog)
            
            json = userLog.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG
                    
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
                let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                      
            syncDao.insert(record : sync);
        }
        
        database.close()
    }
    
    func incompleteSlide (slide: SlideModel)
    {
        //print("Notification: \(Constants.NOTIFICATION_NAME_INCOMPLETED_SLIDE) ")
       // NotificationCenter.default.post(name:Constants.NOTIFICATION_NAME_INCOMPLETED_SLIDE,
       //                                 object: nil, userInfo: ["slideUuid": slide.uuid])
    }
    
    func completeSlide( slide : SlideModel)
    {
        let db = database.open()
        let slideDao = SlideDao(db: db)
        let capsuleDao = CapsuleDao(db: db)
        let topicDao = TopicDao(db: db)
        let syncDao = SyncDao(db: db)
        let progressDao = ProgressDao(db: db)
        let userLogDao = UserLogDao(db: db)
        
        
        var updateCapsuleAndTopics = false
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)
        
        let capsule = capsuleDao.selectByUuid(uuid: slide.capsuleUuid)
        let topic = topicDao.selectByUuid(uuid: slide.topicUuid)
 
        let userUuid = appData.userUuid
        var json : [String: Any]
        var sync : SyncModel
        var userLog : UserLogModel

        
        
            
        var progressSlide = progressDao.selectBySlideUuidAndUserUuid(slideUuid: slide.uuid, userUuid: userUuid)
        var progressCapsule = progressDao.selectByCapsuleUuidAndUserUuid(capsuleUuid: slide.capsuleUuid, userUuid: userUuid)
        var progressTopic = progressDao.selectByTopicUuidAndUserUuid(topicUuid: slide.topicUuid, userUuid: userUuid)
        
        if progressTopic.id == 0 {
            userLog = UserLogModel()
            userLog.userUuid = userUuid
            userLog.companyUuid = topic.companyUuid
            userLog.topicUuid = topic.uuid
            userLog.activity = Constants.USER_LOG_ACTIVITY_START_TOPIC
            userLog.addedOn = dateOn
            userLogDao.insert(record: userLog)
            
            json = userLog.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG
                    
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
                let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                      
            syncDao.insert(record : sync);
        }
        
        if progressCapsule.id == 0 {
            userLog = UserLogModel()
            userLog.userUuid = userUuid
            userLog.companyUuid = topic.companyUuid
            userLog.topicUuid = topic.uuid
            userLog.capsuleUuid = capsule.uuid
            userLog.activity = Constants.USER_LOG_ACTIVITY_START_CAPSULE
            userLog.addedOn = dateOn
            userLogDao.insert(record: userLog)
            
            json = userLog.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG
                    
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
                let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                      
            syncDao.insert(record : sync);
        }

        if progressSlide.id == 0 {
            progressSlide.userUuid = userUuid
            progressSlide.companyUuid = topic.companyUuid
            progressSlide.topicUuid = topic.uuid
            progressSlide.capsuleUuid = capsule.uuid
            progressSlide.slideUuid = slide.uuid
            progressSlide.viewSlides = 0
            progressSlide.totalSlides = 0
            progressSlide.progress = 0
            progressSlide.type = Constants.PROGRESS_TYPE_SLIDE
            progressSlide.returning = 0
            progressSlide.returningAfterCompleted = 0
            progressSlide.completed = 1
            progressSlide.addedOn = dateOn
            progressSlide.updatedOn = dateOn
            progressDao.insert(record: progressSlide)
            
            updateCapsuleAndTopics = true
        } else {
            if  progressCapsule.completed == 1 && appData.capsuleUuidActive != appData.capsuleUuidOld {
                updateCapsuleAndTopics = true
            }
        }
        /*
        else {
            
            if progressCapsule.id > 0 && progressCapsule.completed == 1 {
            
                progressSlide.returningAfterCompleted = progressSlide.returningAfterCompleted + 1
                    
                progressSlide.updatedOn = dateOn
                progressDao.update(record: progressSlide)
            }
        }*/
               
        json = progressSlide.toJson()
        json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS
                    
        sync = SyncModel();
        sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
        if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
           let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                sync.data = data
            }
                  
        syncDao.insert(record : sync);
                
        userLog = UserLogModel()
        userLog.userUuid = userUuid
        userLog.companyUuid = topic.companyUuid
        userLog.topicUuid = topic.uuid
        userLog.capsuleUuid = capsule.uuid
        userLog.slideUuid = slide.uuid
        userLog.activity = slide.type == Constants.SLIDE_TYPE_QUIZ ? Constants.USER_LOG_ACTIVITY_APPROVED_TEST :  Constants.USER_LOG_ACTIVITY_VIEW_SLIDE
        userLog.addedOn = dateOn
        userLogDao.insert(record: userLog)
                    
                    
        json = userLog.toJson()
        json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG
                
        sync = SyncModel();
        sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
        if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
            let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                sync.data = data
            }
                  
        syncDao.insert(record : sync);
        
        if updateCapsuleAndTopics {
        
            var totalSlides = slideDao.getCountByCapsuleUuid(capsuleUuid: slide.capsuleUuid)
            var totalViews = progressDao.getCountSlideCompletedByCapsuleUuidAndUserUuid(capsuleUuid: slide.capsuleUuid, userUuid: userUuid)
            var progress = totalSlides > 0 ? ((totalViews * 100) / totalSlides) : 0

            
            if progressCapsule.id == 0 {
         
                progressCapsule = ProgressModel()
                progressCapsule.userUuid = userUuid
                progressCapsule.companyUuid = topic.companyUuid
                progressCapsule.topicUuid = slide.topicUuid
                progressCapsule.capsuleUuid = slide.capsuleUuid
                progressCapsule.type = Constants.PROGRESS_TYPE_CAPSULE
                
                progressCapsule.addedOn = dateOn
                progressCapsule.updatedOn = dateOn
                progressCapsule.viewSlides = totalViews
                progressCapsule.totalSlides = totalSlides
                progressCapsule.progress = Double(progress)
                
                progressDao.insert(record: progressCapsule)
                
 
                
            } else {
                progressCapsule.updatedOn = dateOn
                progressCapsule.viewSlides = totalViews
                progressCapsule.totalSlides = totalSlides
                progressCapsule.progress = Double(progress)
                

                
                if progressCapsule.completed == 1 && appData.capsuleUuidActive != appData.capsuleUuidOld {
                    progressCapsule.returningAfterCompleted = progressCapsule.returningAfterCompleted + 1
                }
                progressDao.update(record: progressCapsule)

            }
        
           appData.capsuleUuidOld = appData.capsuleUuidActive
           appData.save()
            
            

                
            json = progressCapsule.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS
                    
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
               let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                    sync.data = data
                }
                  
            syncDao.insert(record : sync);
                    
            totalSlides = slideDao.getCountByTopicUuid(topicUuid: slide.topicUuid)
            totalViews = progressDao.getCountSlideCompletedByTopicUuidAndUserUuid(topicUuid: slide.topicUuid, userUuid: userUuid)
            progress = totalSlides > 0 ? ((totalViews * 100) / totalSlides) : 0


            if progressTopic.id == 0 {
                progressTopic = ProgressModel()
                progressTopic.userUuid = userUuid
                progressTopic.companyUuid = topic.companyUuid
                progressTopic.topicUuid = slide.topicUuid
                progressTopic.type = Constants.PROGRESS_TYPE_TOPIC
                
                progressTopic.addedOn = dateOn
                progressTopic.updatedOn = dateOn
                progressTopic.viewSlides = totalViews
                progressTopic.totalSlides = totalSlides
                progressTopic.progress = Double(progress)
                
                progressDao.insert(record: progressTopic)
                
            } else {
            
                progressTopic.updatedOn = dateOn
                progressTopic.viewSlides = totalViews
                progressTopic.totalSlides = totalSlides
                progressTopic.progress = Double(progress)
                progressDao.update(record: progressTopic)
            }
                

                
            json = progressTopic.toJson()
            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS
                    
            sync = SyncModel();
            sync.type = Constants.SYNC_ADAPTER_TYPE_SYNC
            if let theJSONData = try?  JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
               let data = String(data: theJSONData, encoding: String.Encoding.ascii) {
                   sync.data = data
                }
                  
            syncDao.insert(record : sync);
        }
        
        
        
        if slide.completed == 1 {
        
            print("Notification: \(Constants.NOTIFICATION_NAME_COMPLETED_SLIDE) ")
            NotificationCenter.default.post(name:Constants.NOTIFICATION_NAME_COMPLETED_SLIDE,  object: nil, userInfo: ["slideUuid": slide.uuid])
        }
        
        if ( updateCapsuleAndTopics ) {
            
            print("Notification: \(Constants.NOTIFICATION_NAME_CHANGE_PERCENTAJE_COMPLETED_CAPSULE) ")
            NotificationCenter.default.post(name: Constants.NOTIFICATION_NAME_CHANGE_PERCENTAJE_COMPLETED_CAPSULE, object: nil, userInfo:["capsuleUuid": slide.capsuleUuid])
            
            
            print("Notification: \(Constants.NOTIFICATION_NAME_CHANGE_PERCENTAJE_COMPLETED_TOPIC) ")
            NotificationCenter.default.post(name: Constants.NOTIFICATION_NAME_CHANGE_PERCENTAJE_COMPLETED_TOPIC, object: nil, userInfo:["topicUuid": slide.topicUuid])
            
        }
        
        database.close()
          
    }

    
    
    
    public func syncFromServer(json : JSON?, refresh : Bool = false) -> Bool
    {
        let db = database.open()
        let companyDao = CompanyDao(db: db)
        let topicDao = TopicDao(db: db)
        let capsuleDao = CapsuleDao(db: db)
        let slideDao = SlideDao(db: db)
        let quizDao = QuizDao(db: db)
        let questionDao = QuestionDao(db: db)
        let answerDao = AnswerDao(db: db)
        let userLogDao = UserLogDao(db: db)
        let progressDao = ProgressDao(db: db)
        let userExtendedDao = UserExtendedDao(db: db)
        let userNotificationDao = UserNotificationDao(db: db)

        answerDao.removeAll()
        questionDao.removeAll()
        quizDao.removeAll()
                                
        slideDao.removeAll()
        capsuleDao.removeAll()
        topicDao.removeAll()
        companyDao.removeAll()
                        
        userExtendedDao.removeAll()
        
        //userLogDao.removeAll()
        //progressDao.removeAll()
        //userNotificationDao.removeAll()

        var companyModel : CompanyModel
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)
            
        if json?["data"]["max_date_changes"] != ""  {
            let maxDateChanges = json?["data"]["max_date_changes"].string ?? ""
            
            //print("maxDateChanges : \(maxDateChanges)")
            appData.maxDateChanges = maxDateChanges
        } 
        
        if !refresh  && json?["data"]["device"] != "" {
            let deviceAes = json?["data"]["device"]["aes"].string ?? ""
            let devicePassword = json?["data"]["device"]["password"].string ?? ""
            
            //print("deviceAes: \(deviceAes)")
           // print("devicePassword: \(devicePassword)")
            appData.deviceAes = deviceAes
            appData.devicePassword = devicePassword
            
        }
        if json?["data"]["user"] != "" {
            let userUuid = json?["data"]["user"]["uuid"].string ?? ""
            let userFirstName = json?["data"]["user"]["first_name"].string ?? ""
            let userLastName = json?["data"]["user"]["last_name"].string ?? ""
            let userEmail = json?["data"]["user"]["email"].string ?? ""
            let userImage = json?["data"]["user"]["image"].string ?? ""
   
            //print("userUuid : \(userUuid)")
            //print("userFirstName : \(userFirstName)")
            //print("userLastName: \(userLastName)")
            //print("userEmail : \(userEmail)")
            //print("userImage : \(userImage)")
                 
            appData.userUuid = userUuid
            appData.userFirstname = userFirstName
            appData.userLastname =  userLastName
            appData.userEmail = userEmail
            appData.userImage = userImage
        }
    
        appData.lastCheckChanges = dateOn
        appData.topicUuidActive = ""
        appData.capsuleUuidActive = ""
        appData.capsuleUuidOld = ""
        appData.slideUuidActive = ""
        appData.save()
        
        userLogDao.removeAllUserUuidNotEqual(userUuid: appData.userUuid)
        progressDao.removeAllUserUuidNotEqual(userUuid: appData.userUuid)
        userNotificationDao.removeAllUserUuidNotEqual(userUuid: appData.userUuid)
                                    
        if json?["data"]["topics"] != "" {
            var topicModel : TopicModel
            var capsuleModel : CapsuleModel
            var slideModel : SlideModel
            
            for topic in json!["data"]["topics"]
            {
                                    
                companyModel = CompanyModel()
                companyModel.uuid = topic.1["company_uuid"].string ?? ""
                companyModel.name = topic.1["company_name"].string ?? ""
                companyModel.image = topic.1["company_image"].string ?? ""
                
               // print("companyUuid : \(companyModel.uuid)")
               // print("companyName : \(companyModel.name)")
               // print("companyImage : \(companyModel.image)")
                
                let company = companyDao.selectByUuid(uuid:  companyModel.uuid)
                if(company.uuid.isEmpty) {
                    companyDao.insert(company: companyModel)
                } else {
                    companyDao.update(company: companyModel)
                }
                                        
                topicModel = TopicModel()
                topicModel.companyUuid = companyModel.uuid
                topicModel.uuid = topic.1["uuid"].string ?? ""
                topicModel.name  = topic.1["name"].string ?? ""
                topicModel.description = topic.1["description"].string ?? ""
                topicModel.image = topic.1["image"].string ?? ""
                topicModel.position = Int(topic.1["position"].string ?? "") ?? 1
                topicModel.addedOn = topic.1["added_on"].string ?? ""
                topicModel.updatedOn = topic.1["updated_on"].string ?? ""
                
                
               // print("topiccompanyUuid: \(topicModel.companyUuid)")
                //print("topicUuid: \(topicModel.uuid)")//
               // print("topicName: \(topicModel.name)")
                //print("topicDescription: \(topicModel.description)")//
                //print("topicImage: \(topicModel.image)")
                //print("topicPosition: \(topicModel.position)")

                                        
                  
                // Insert Topics in DB
                topicDao.insert(topic: topicModel)
                                        
                for capsule in topic.1["capsules"]
                {
                                            
                    capsuleModel = CapsuleModel()
                    capsuleModel.topicUuid = topicModel.uuid
                    capsuleModel.uuid = capsule.1["uuid"].string ?? ""
                    capsuleModel.name = capsule.1["name"].string ?? ""
                    capsuleModel.description = capsule.1["description"].string ?? ""
                    capsuleModel.image = capsule.1["image"].string ?? ""
                    capsuleModel.position = Int(capsule.1["position"].string ?? "") ?? 1
                    capsuleModel.linkComments = capsule.1["link_comments"].string ?? ""
                    capsuleModel.linkCommentAdd = capsule.1["link_comment_add"].string ?? ""
                    capsuleModel.totalComments = Int(capsule.1["total_comments"].string ?? "") ?? 0
                    capsuleModel.totalRating = Decimal(Double(capsule.1["total_rating"].string ?? "") ?? 0)
                    capsuleModel.addedOn = capsule.1["added_on"].string ?? ""
                    capsuleModel.updatedOn = capsule.1["updated_on"].string ?? ""
                    
                    //print("capsuletopicUuid: \(capsuleModel.topicUuid)")
                    //print("capsuleUuid: \(capsuleModel.uuid)")
                    //print("capsuleName: \(capsuleModel.name)")
                    //print("capsuleDescription: \(capsuleModel.description)")
                    //print("capsuleImage: \(capsuleModel.image)")
                    //print("capsulePosition: \(capsuleModel.position)")
                    //print("capsuleLinkComments: \(capsuleModel.linkComments)")
                    //print("capsuleLinkCommentAdd: \(capsuleModel.linkCommentAdd)")
                    //print("capsuleTotalComments: \(capsuleModel.totalComments)")
                    //print("capsuleTotalRating: \(capsuleModel.totalRating)")

                                            
                    // Insert Capsules in DB
                    capsuleDao.insert(capsule: capsuleModel)
                                            
                    for slide in capsule.1["slides"]
                    {
                        slideModel = SlideModel()
                        slideModel.topicUuid = capsuleModel.topicUuid
                        slideModel.capsuleUuid = capsuleModel.uuid
                        slideModel.uuid = slide.1["uuid"].string ?? ""
                        slideModel.quizUuid = slide.1["quiz_uuid"].string ?? ""
                        slideModel.name = slide.1["name"].string ?? ""
                        slideModel.description = slide.1["description"].string ?? ""
                        slideModel.position = Int(slide.1["position"].string ?? "") ?? 1
                        slideModel.background = slide.1["background"].string ?? ""
                        slideModel.file = slide.1["file"].string ?? ""
                        slideModel.type = slide.1["type"].string ?? ""
                        slideModel.addedOn = slide.1["added_on"].string ?? ""
                        slideModel.updatedOn = slide.1["updated_on"].string ?? ""
                        
                        
                        //print("slidetopicUuid: \(slideModel.topicUuid)")
                        //print("slidecapsuleUuid: \(slideModel.capsuleUuid)")
                        //print("slideUuid: \(slideModel.uuid)")
                        //print("slideQuizUuid: \(slideModel.quizUuid)")
                        //print("slideName: \(slideModel.name)")
                        //print("slideDescription: \(slideModel.description)")
                        //print("slidePosition: \(slideModel.position)")
                        //print("slideBackground: \(slideModel.background)")
                        //print("slideFile: \(slideModel.file)")
                        //print("slideTye: \(slideModel.type)")
                                                
                        // Insert Slides in DB
                        slideDao.insert(slide: slideModel)
                    }
                }
            }
        }
        
        if json?["data"]["quizzes"] != "" {
            var quizModel : QuizModel
            var questionModel : QuestionModel
            var answerModel  : AnswerModel
            for quiz in json!["data"]["quizzes"]
            {
                

                companyModel = CompanyModel()
                companyModel.uuid = quiz.1["company_uuid"].string ?? ""
                companyModel.name = quiz.1["company_name"].string ?? ""
                companyModel.image =  quiz.1["company_image"].string ?? ""
                
                //print("companyUuid : \(companyModel.uuid)")
                //print("companyName : \(companyModel.name)")
                //print("companyImage : \(companyModel.image)")
                
                let company = companyDao.selectByUuid(uuid:  companyModel.uuid)
                if(company.uuid.isEmpty) {
                    companyDao.insert(company: companyModel)
                } else {
                    companyDao.update(company: companyModel)
                }
                
                quizModel = QuizModel()
                quizModel.companyUuid = company.uuid
                quizModel.uuid = quiz.1["uuid"].string ?? ""
                quizModel.name = quiz.1["name"].string ?? ""
                quizModel.text = quiz.1["text"].string ?? ""
                quizModel.failed = quiz.1["failed"].string ?? ""
                quizModel.points = Int(quiz.1["points"].string ?? "") ?? 0
                quizModel.minimumPointsRequired = Int(quiz.1["minimum_points_required"].string ?? "") ?? 0
                quizModel.maxTime = Int(quiz.1["max_time"].string ?? "") ?? 0
                quizModel.addedOn = quiz.1["added_on"].string ?? ""
                quizModel.updatedOn = quiz.1["updated_on"].string ?? ""
                                        
               
                //print("quizcompanyUuid: \(quizModel.companyUuid)")
                //print("quizUuid: \(quizModel.uuid)")
                //print("quizName: \(quizModel.name)")
                //print("quizText: \(quizModel.text)")
                //print("quizFailed: \(quizModel.failed)")
                //print("quizPoints: \(quizModel.points)")
                //print("quizMinimumPointsRequired: \(quizModel.minimumPointsRequired)")
                //print("quizMaxTime: \(quizModel.maxTime)")

                
                quizDao.insert(quiz: quizModel)
                
                for question in quiz.1["questions"]
                {
                    questionModel = QuestionModel()
                    questionModel.quizUuid = quizModel.uuid
                    questionModel.uuid = question.1["uuid"].string ?? ""
                    questionModel.text  = question.1["text"].string ?? ""
                    questionModel.type = question.1["type"].string ?? ""
                    questionModel.points  = Int(question.1["points"].string ?? "") ?? 0
                    questionModel.max_length = Int(question.1["maxlength"].string ?? "") ?? 0
                    questionModel.addedOn = question.1["added_on"].string ?? ""
                    questionModel.updatedOn = question.1["updated_on"].string ?? ""
                    
                    //print("questionQuizUuid: \(questionModel.quizUuid)")
                    //print("questionId: \(questionModel.uuid)")
                    //print("questionText: \(questionModel.text)")
                    //print("questionType: \(questionModel.type)")
                    //print("questionPoints: \(questionModel.points)")
                    //print("questionMaxLength: \(questionModel.max_length)")

                    
                    questionDao.insert(question: questionModel)
                    
                    for answer in question.1["answers"]
                    {
                        answerModel = AnswerModel()
                        answerModel.questionUuid = questionModel.uuid
                        answerModel.uuid  = answer.1["uuid"].string ?? ""
                        answerModel.text = answer.1["text"].string ?? ""
                        answerModel.correct = Int(answer.1["correct"].string ?? "") ?? 0
                        answerModel.points = Int(answer.1["points"].string ?? "") ?? 0
                        answerModel.addedOn = answer.1["added_on"].string ?? ""
                        answerModel.updatedOn = answer.1["updated_on"].string ?? ""
                        
                        //print("answerQuestionUuid: \(answerModel.questionUuid)")
                        //print("answerId: \(answerModel.uuid)")
                        //print("answerText: \(answerModel.text)")
                        //print("answerCorrect: \(answerModel.correct)")

                        
                        
                        answerDao.insert(answer: answerModel)

                    }
                    
                    
                }
                
            }
        }
        
        if json?["data"]["userlog"] != "" {

            var userLogModel : UserLogModel
            for userlog in json!["data"]["userlog"]
            {
                userLogModel = UserLogModel()
                userLogModel.companyUuid = userlog.1["company_uuid"].string ?? ""
                userLogModel.userUuid = userlog.1["user_uuid"].string ?? ""
                userLogModel.topicUuid = userlog.1["topic_uuid"].string ?? ""
                userLogModel.capsuleUuid = userlog.1["capsule_uuid"].string ?? ""
                userLogModel.slideUuid = userlog.1["slide_uuid"].string ?? ""
                userLogModel.activity = userlog.1["activity"].string ?? ""
                userLogModel.addedOn = userlog.1["added_on"].string ?? ""
                
                userLogDao.insert(record: userLogModel)
            }
        }
 
        if json?["data"]["extended"] != "" {

            var userExtendedModel : UserExtendedModel
            for userExtended in json!["data"]["extended"]
            {
                companyModel = CompanyModel()
                companyModel.uuid = userExtended.1["company_uuid"].string ?? ""
                companyModel.name = userExtended.1["company_name"].string ?? ""
                companyModel.image =  userExtended.1["company_image"].string ?? ""
                
                print("companyUuid : \(companyModel.uuid)")
                print("companyName : \(companyModel.name)")
                print("companyImage : \(companyModel.image)")
                
                let company = companyDao.selectByUuid(uuid: companyModel.uuid)
                if(company.uuid.isEmpty) {
                    companyDao.insert(company: companyModel)
                } else {
                    companyDao.update(company: companyModel)
                }
                
                for detail in userExtended.1["details"]
                {
                    userExtendedModel = UserExtendedModel()
                    userExtendedModel.companyUuid = companyModel.uuid
                    userExtendedModel.uuid = detail.1["uuid"].string ?? ""
                    userExtendedModel.label = detail.1["label"].string ?? ""
                    userExtendedModel.value = detail.1["value"].string ?? ""
                    
                    userExtendedDao.insert(record: userExtendedModel)
                }
            }
        }
        
        if json?["data"]["progress"] != "" {
            
            var progressModel : ProgressModel
            for progress in json!["data"]["progress"] {
                
                
                let userUuid = progress.1["user_uuid"].string ?? ""
                let topicUuid = progress.1["topic_uuid"].string ?? ""
                let capsuleUuid = progress.1["capsule_uuid"].string ?? ""
                let slideUuid = progress.1["slide_uuid"].string ?? ""
                let type = progress.1["type"].string ?? ""
                
                
                switch type {
                    case Constants.PROGRESS_TYPE_TOPIC:
                        progressModel = progressDao.selectByTopicUuidAndUserUuid(topicUuid: topicUuid, userUuid: userUuid)
                        break
                        
                    case Constants.PROGRESS_TYPE_CAPSULE:
                        progressModel = progressDao.selectByCapsuleUuidAndUserUuid(capsuleUuid: capsuleUuid, userUuid: userUuid)
                        break
                        
                    case Constants.PROGRESS_TYPE_SLIDE:
                        progressModel = progressDao.selectBySlideUuidAndUserUuid(slideUuid: slideUuid, userUuid: userUuid)
                        break
                    default:
                        continue
                    }
     
                
                if progressModel.id == 0 {
                    progressModel = ProgressModel()
                    progressModel.userUuid = userUuid
                    progressModel.topicUuid = topicUuid
                    progressModel.capsuleUuid = capsuleUuid
                    progressModel.slideUuid = slideUuid
                    progressModel.type = type
                    progressModel.companyUuid = progress.1["company_uuid"].string ?? ""
                    progressModel.progress = Double(progress.1["progress"].string ?? "") ?? 0.0
                    progressModel.totalSlides = Int(progress.1["total_slides"].string ?? "") ?? 0
                    progressModel.viewSlides = Int(progress.1["view_slides"].string ?? "") ?? 0
                    progressModel.returning = Int(progress.1["returning"].string ?? "") ?? 0
                    progressModel.returningAfterCompleted = Int(progress.1["returning_after_completed"].string ?? "") ?? 0
                    progressModel.completed = Int(progress.1["completed"].string ?? "") ?? 0
                    progressModel.addedOn = progress.1["added_on"].string ?? ""
                    progressModel.updatedOn = progress.1["updated_on"].string ?? ""
                        
                    progressDao.insert(record: progressModel)
                }

            }
        }
         
        database.close()
        return true;
    }
    
    
}