Proyectos de Subversion Iphone Microlearning

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

import Foundation
import SwiftyJSON

class DataService
{
    func completeCapsule(topicModel : TopicModel, capsuleModel : CapsuleModel)
    {
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)
        
        let preference = Preference.sharedInstance
        let userUuid = preference.userUuid
        var json : [String: Any]
        var sync : SyncModel
        var userLog : UserLogModel

        let syncDao = SyncDao()
        let progressDao = ProgressDao()
        let userLogDao = UserLogDao()
            
        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);
        }

        
    }
    
    
    func completeTopic(topicModel : TopicModel, capsuleModel : CapsuleModel)
    {
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)
        
        let preference = Preference.sharedInstance
        let userUuid = preference.userUuid
        var json : [String: Any]
        var sync : SyncModel
        var userLog : UserLogModel

        let syncDao = SyncDao()
        let progressDao = ProgressDao()
        let userLogDao = UserLogDao()
            
        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 = 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.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);
        }
    }
    
    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)
    {
        var changeProgress = false
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)
            
        let slideDao = SlideDao()
           
        let capsuleDao = CapsuleDao()
        let capsule = capsuleDao.selectByUuid(uuid: slide.capsuleUuid)
            
            
        let topicDao = TopicDao()
        let topic = topicDao.selectByUuid(uuid: slide.topicUuid)

        let preference = Preference.sharedInstance
        let userUuid = preference.userUuid
        var json : [String: Any]
        var sync : SyncModel
        var userLog : UserLogModel

        let syncDao = SyncDao()
        let progressDao = ProgressDao()
        let userLogDao = UserLogDao()
        
            
        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)
            
            changeProgress = 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 changeProgress {
        
            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 && slide.capsuleUuid != preference.capsuleUuidOld {
                    progressCapsule.returningAfterCompleted = progressCapsule.returningAfterCompleted + 1
                    progressDao.update(record: progressCapsule)
                                
                    
                    let preference = Preference.sharedInstance
                    preference.capsuleUuidOld = slide.capsuleUuid
                    preference.save()
                    
                } else {
                    progressDao.update(record: progressCapsule)
                }
            }
            
            

                
            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);
                    
            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 = 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);
        }
        
        
        print("Notification: \(Constants.NOTIFICATION_NAME_COMPLETED_SLIDE) ")
        NotificationCenter.default.post(name:Constants.NOTIFICATION_NAME_COMPLETED_SLIDE,
                                        object: nil, userInfo: ["slideUuid": slide.uuid])
        
        if (changeProgress) {
            
            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])
            
        }
          
    }

    
    
    
   public func syncFromServer(json : JSON?) -> Bool
    {

    
        let preference = Preference.sharedInstance
        let companyDao = CompanyDao()
        let topicDao = TopicDao()
        let capsuleDao = CapsuleDao()
        let slideDao = SlideDao()
        let quizDao = QuizDao()
        let questionDao = QuestionDao()
        let answerDao = AnswerDao()
        let userLogDao = UserLogDao()
        let progressDao = ProgressDao()
        let userExtendedDao = UserExtendedDao()

        answerDao.removeAll()
        questionDao.removeAll()
        quizDao.removeAll()
                                
        slideDao.removeAll()
        capsuleDao.removeAll()
        topicDao.removeAll()
        companyDao.removeAll()
                                
        userLogDao.removeAll()
        progressDao.removeAll()
        userExtendedDao.removeAll()
        
        var companyModel : CompanyModel
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE


            
        if(json?["data"]["max_date_changes"] != "") {
            let maxDateChanges = json?["data"]["max_date_changes"].string ?? ""
            
            print("maxDateChanges : \(maxDateChanges)")
            
            preference.maxDateChanges = maxDateChanges
        } 
        
        if(json?["data"]["device"] != "") {
            let deviceAes = json?["data"]["device"]["aes"].string ?? ""
            let devicePassword = json?["data"]["device"]["password"].string ?? ""
            
            print("deviceAes: \(deviceAes)")
            print("devicePassword: \(devicePassword)")
            preference.aes = deviceAes
            preference.password = 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)")
     
                 
            preference.userUuid = userUuid
            preference.firstName = userFirstName
            preference.lastName =  userLastName
            preference.email = userEmail
            preference.image = userImage
            

                    
        }
    
        preference.topicUuidActive = Constants.PREFERENCE_EMPTY_ID
        preference.capsuleUuidActive = Constants.PREFERENCE_EMPTY_ID
        preference.slideUuidActive = Constants.PREFERENCE_EMPTY_ID
        preference.save()

                                    
        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
                
                
                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
                    
                    print("capsuletopicUuid: \(capsuleModel.topicUuid)")
                    print("capsuleUuid: \(capsuleModel.uuid)")
                    print("capsuleName: \(capsuleModel.name)")
                    print("capsuleDescription: \(capsuleModel.description)")
                    print("capsuleImage: \(capsuleModel.image)")
                    print("capsulePosition: \(capsuleModel.position)")

                                            
                    // 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 ?? ""
                        
                        
                        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
                                        
               
                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
                    
                    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
                        
                        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)
                }

            }
        }
                
        /*
        let now = Date()
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
        let dateOn = dateFormatter.string(from: now)

        userUuid = preference.string(forKey: Constants.PREFERENCE_FIELD_USER_UUID) ?? ""
                                
                                
        var userLog = UserLogModel()
        userLog.userUuid = userUuid
        userLog.companyUuid = ""
        userLog.topicUuid = ""
        userLog.capsuleUuid = ""
        userLog.slideUuid = ""
        userLog.activity = Constants.USER_LOG_ACTIVITY_SIGNIN;
        userLog.addedOn =  dateOn
             
        userLogDao.insert(record : userLog);
                                
        var json = userLog.toJson()
        json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_USER_LOG
                                
        var 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
        }
                                
        let syncDao = SyncDao()
        syncDao.insert(record : sync)
        */
        
        return true;
    }
    
    
}