Proyectos de Subversion Iphone Microlearning - Inconcert

//

//  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;

    }

}