Proyectos de Subversion Iphone Microlearning - Nuevo Interface

//
//  PdfView.swift
//  twogetskills
//
//  Created by Efrain Yanez Recanatini on 4/26/22.
//

import Foundation
import SwiftUI
import PDFKit
import Network
import Alamofire
import SwiftyJSON
import TTGSnackbar
import NavigationStack


struct PdfViewerView: View {
    
    @State private var backToGallery : Bool = false
    
    @State private var isCompleted : Bool = false
    @State private var url : URL? = nil
    
    private var slideModel : SlideModel
    private var slideTitle : String
    
   
    
    

    
    init(slideUuid : String)
    {
        let slideDao = SlideDao.sharedInstance
        self.slideModel = slideDao.selectByUuid(uuid: slideUuid)

        if self.slideModel.name.count > Constants.APP_BAR_TITLE_MAX_LENGTH {
            slideTitle = String(Array(self.slideModel.name)[0...Constants.APP_BAR_TITLE_MAX_LENGTH]) + "..."
        } else {
            slideTitle = self.slideModel.name
        }
        
        

        
        //print("Viewer PDF: \(slideModel.file) ")
        
        //self.url = URL(string: slideModel.file)



    }
    
    var body: some View {
        VStack(spacing: 0) {
            PopView(
                destination: .root,
                isActive: self.$backToGallery,
                label: {
                    Text("")
                    
                }
            ).frame( height: 0)
            
            HStack {
                Button(action: {
                    let dataService = DataService()
                    dataService.completeSlide(slide: slideModel)
                    self.backToGallery.toggle()
                    
                    
               
                }, label: {

                    
                    Image(systemName: "chevron.backward")
                    .frame(width: 32, height: 32, alignment: /*@START_MENU_TOKEN@*/.center/*@END_MENU_TOKEN@*/)
                    .aspectRatio(contentMode: .fit)
                    .foregroundColor(Color("color_app_bar_foreground"))
                })
                .padding(.leading, 16)
                
                Text(self.slideTitle)
                .font(Font.custom(Config.FONT_NAME_REGULAR, size: Config.FONT_SIZE_APP_BAR_HEAD1 ))
                .foregroundColor(Color("color_app_bar_foreground"))
                    .padding(.leading, 4)
                
                Spacer()
            }
            .background(Color("color_app_bar_background"))
            .edgesIgnoringSafeArea(.top)
            .frame(height: 50)
            Divider()

            if self.url != nil {
                GeometryReader { geometry in
                
                    PDFKitRepresentedView(url!)
                    .frame(
                        width: geometry.size.width,
                        height: geometry.size.height,
                        alignment: /*@START_MENU_TOKEN@*/.center/*@END_MENU_TOKEN@*/)
                    .border(/*@START_MENU_TOKEN@*/Color.black/*@END_MENU_TOKEN@*/, width: /*@START_MENU_TOKEN@*/1/*@END_MENU_TOKEN@*/)
                    
                }
            }
                
            
            Spacer()

           
        }.onAppear {
            let appDao = AppDao.sharedInstance
            let appData = appDao.selectOne()
            let headerSecurity = HeaderSecurity()
            
            
            let headerAccept = HTTPHeader(name : Constants.HTTP_HEADER_ACCEPT, value: Constants.HTTP_HEADER_ACCEPT_VALUE)
            
            let headerRand = HTTPHeader(name : Constants.HTTP_HEADER_SECURITY_RAND, value: String(headerSecurity.rand))
            
            let headerToken = HTTPHeader(name : Constants.HTTP_HEADER_SECURITY_TOKEN, value: appData.deviceUuid)
            
            let headerCreated = HTTPHeader(name : Constants.HTTP_HEADER_SECURITY_CREATED, value: String(headerSecurity.created))
            
            let headerSecret = HTTPHeader(name : Constants.HTTP_HEADER_SECURITY_SECRET, value: headerSecurity.secret)
            
            
            var headers = HTTPHeaders()
            headers.add(headerAccept)
            headers.add(headerRand)
            headers.add(headerToken)
            headers.add(headerCreated)
            headers.add(headerSecret)
            
            
            /*
                Constants.HTTP_HEADER_ACCEPT: Constants.HTTP_HEADER_ACCEPT_VALUE,
                Constants.HTTP_HEADER_SECURITY_RAND: String(headerSecurity.rand),
                Constants.HTTP_HEADER_SECURITY_TOKEN: appData.deviceUuid,
                Constants.HTTP_HEADER_SECURITY_CREATED: String(headerSecurity.created) ,
                Constants.HTTP_HEADER_SECURITY_SECRET: headerSecurity.secret,
            ]*/
            /*
            let destination = DownloadRequest.suggestedDownloadDestination(for: .documentDirectory)
            */
            /*
            let destination = DownloadRequest.suggestedDownloadDestination(for: .documentDirectory, in: .userDomainMask)
                    
            
            let destination: DownloadRequest.DownloadFileDestination
            
    
            print("Download")
            AF.download(
                url!,
                method: .get,
                encoding: JSONEncoding.default,
                headers: headers, to: destination).downloadProgress(closure: { (progress) in
            //progress closure
        }).response(completionHandler: { (DefaultDownloadResponse) in
            //here you able to access the DefaultDownloadResponse
            //result closure
        })*/
            
            /*
                Constants.HTTP_HEADER_ACCEPT: Constants.HTTP_HEADER_ACCEPT_VALUE,
                Constants.HTTP_HEADER_SECURITY_RAND: String(headerSecurity.rand),
                Constants.HTTP_HEADER_SECURITY_TOKEN: appData.deviceUuid,
                Constants.HTTP_HEADER_SECURITY_CREATED: String(headerSecurity.created) ,
                Constants.HTTP_HEADER_SECURITY_SECRET: headerSecurity.secret,
            ]*/
            
            //AF.download()
                /*
                .downloadProgress { progress in
                    print("Download Progress: \(progress.fractionCompleted)")
                }
                .responseData { response in
                    do {
                        try response.result.value?.write(to: File.getPath(filename: "_cr"))
                    } catch {
                        print("oops !")
                    }
                }*/
            
            
            
            let destination = DownloadRequest.suggestedDownloadDestination(for: .documentDirectory)
             
            print("download")
            AF.download(
                URL(string: slideModel.file)!,
                method: .get,
                encoding: JSONEncoding.default,
                headers: headers).downloadProgress(closure: { (progress) in
                        print(progress.completedUnitCount)
                    }).responseData { (response) in
                        
                        self.url = response.fileURL
                        
                        //print("fileURL = \(fileURL)")
                        
                        /*
                        let destiUrl = responce.destiUrl? ""
                        print(destiUrl!)
                        */
                        /*
                        let newUrl = destiUrl?.deletingPathExtension().appendingPathExtension("zip")
                        do {
                            try FileManager.default.copyItem(at: destiUrl!, to: newUrl!)
             
                            let unzipDirectory = try Zip.quickUnzipFile(newUrl!)
                            print(unzipDirectory.absoluteString)
                       }
                        catch let error as NSError{
                            print(error)
                        }*/
                }
        }
    }
}


struct PdfViewerView_Previews: PreviewProvider {
    static var previews: some View {
        PdfViewerView(slideUuid: "S123")
    }
}