WebSVN – Iphone Microlearning - Nuevo Interface – /twogetskills/View/SigninView.swift

//
//  LoginView.swift
//  twogetskills
//
//  Created by Efrain Yanez Recanatini on 1/27/22.
//

import SwiftUI
import AudioToolbox
import Network
import Alamofire
import SwiftyJSON
import SafariServices
import RNCryptor





struct SigninView: View {

    @Environment(\.openURL) var openURL
    @EnvironmentObject var appNavigation : AppNavigation
    @State var keyboardHeight : CGFloat = 0
    
    private let appData = AppData.sharedInstance

    
    @State private var email: String = "efrain.yanez@leaderslinked.com" {
        didSet {
            if email.count > 250 {
                email = String(email.prefix(250))
                AudioServicesPlayAlertSoundWithCompletion(SystemSoundID(kSystemSoundID_Vibrate)) { return }
            }
        }
    }
    @State private var isValidEmail : Bool = true
    @State private var isEditingEmail : Bool = false
    
    @State private var password: String = "Cesa2020$" {
        didSet {
            if password.count > 25 {
                password = String(password.prefix(25))
                AudioServicesPlayAlertSoundWithCompletion(SystemSoundID(kSystemSoundID_Vibrate)) { return }
            }
        }
    }
        
    @State private var isValidPassword : Bool = true
    @State private var isEditingPassword : Bool = false
    
    @State private var isPasswordShow: Bool = false
    
    
    @State private var goToMain : Bool = false
    
    @State private var showProgressView : Bool = false
    

    
    
    @State private var presentAlert : Bool = false
    @State private var titleAlert : String = ""
    @State private var messageAlert : String = ""


    
    
    var body: some View {
        
        
        ZStack {
            
            Color("color_window_background")
                    .edgesIgnoringSafeArea(.all)
                
            VStack(spacing: 0) {
                    
                HeaderGroupView()
                
                EmailTextFieldGroup(email: self.$email, isEditingEmail: self.$isEditingEmail, isValidEmail: self.$isValidEmail, password: self.$password, isEditingPassword: self.$isEditingPassword, isValidPassword: self.$isValidPassword)
                
                PasswordTextFieldGroup(
                    password: self.$password,
                    isEditingPassword: self.$isEditingPassword,
                    isValidPassword: self.$isValidPassword,
                    isPasswordShow: self.$isPasswordShow
                ).padding(.top, isValidEmail ? 10 : 2)
                
                                   
                
                Button(action: {
                    if(validate()) {
                        signin()
                    }
                }, label: {
                    Text(Config.LANG_SIGNIN_BUTTON_SIGNIN)
                    .font(Font.custom(Config.FONT_NAME_REGULAR, size: 13))
                    .frame(width: UIScreen.main.bounds.width - 32, height: 35)
                    .foregroundColor(Color("color_button_foreground"))
                    .background(Color("color_button_background"))
                    .border(Color("color_button_border"), width: Config.BUTTON_BORDER_SIZE)
                                           .cornerRadius(Config.BUTTON_BORDER_RADIUS)
                                       
                                   })
                                   
                                   .padding(.top, 16)
                                   .padding(.leading, 16)
                                   .padding(.trailing, 16)
                                   
                         
                ButtonSignUpGroup()
                                   
                                   
                
                Spacer()
                
                ButtonForgotPasswordGroup()
            
   
            }
            
         
        }
      
        //}.offset(y : CGFloat(-(self.keyboardHeight / 2)))
        
        .onAppear {
    /*
            NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillShowNotification, object: nil, queue: .main) { (notification) in
                let keyboardHeight: CGFloat = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue.height ?? 0
                
         
                self.keyboardHeight = keyboardHeight
                print("keyboardHeightShow = \(keyboardHeight)")
                
            }*/
            
            NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, object: nil, queue: .main) { (notification) in
            
          
                print("keyboardHeightHide ")
                
            }
        }
        
         .alert(isPresented: $presentAlert) {
            Alert(
                title: Text(self.titleAlert),
                message: Text(self.messageAlert),
                dismissButton: .default(Text("Ok"))
            )
        }

    }
        
    private func signin() -> Void
    {
        self.isEditingEmail = false
        self.isValidEmail = Validator.checkEmail(email: self.email)
        self.isEditingPassword = false
        self.isValidPassword = Validator.checkPassword(password: self.password)
        
        if !self.isValidEmail || !self.isValidPassword {
            return
        }
        
        
        
        let device_uuid = appData.deviceUuid

        print("signin")
        print(" aes  = \(appData.aes) " )
        print(" email  = \(self.email) " )
        print(" password  = \(self.password) " )
        

        let syncDao = SyncDao.sharedInstance
        if appData.aes.isEmpty  {
            
            let syncRecord = syncDao.selectOneByType(type: Constants.SYNC_ADAPTER_TYPE_DEVICE)
                    
            if syncRecord.id > 0 {
                let syncAdapter = SyncAdapter()
                syncAdapter.sync {
                    success in
                }
            }
            
            self.titleAlert = Config.LANG_ERROR_DEVICE_NOT_REGISTER_TITLE
            self.messageAlert = Config.LANG_ERROR_DEVICE_NOT_REGISTER_MESSAGE
            self.presentAlert = true

            return
        }
        
        self.showProgressView = true;

        let emailData = email.data(using: .utf8)!
        let emailCipherData = RNCryptor.encrypt(data: emailData, withPassword: appData.aes)
        let emailEncrypted = emailCipherData.base64EncodedString()
                  
        let passwordData = password.data(using: .utf8)!
        let passwordCipherData = RNCryptor.encrypt(data: passwordData, withPassword: appData.aes)
        let passwordEncrypted = passwordCipherData.base64EncodedString()
                   

        print(" email encrypted = \(emailEncrypted) " )
        print(" password encrypted = \(passwordEncrypted) " )

        let parameters = [
            Constants.POST_SIGNIN_FIELD_APPLICATION_ID: "\(Constants.GLOBAL_APPLICATION_ID)",
            Constants.POST_SYNC_FIELD_DEVICE_UUID: device_uuid,
            Constants.POST_SIGNIN_FIELD_EMAIL: emailEncrypted,
            Constants.POST_SIGNIN_FIELD_PASSWORD: passwordEncrypted,
            Constants.POST_SIGNIN_FIELD_ENCRYPTER: Constants.GLOBAL_ENCRYPTER
        ]
        
        let headers: HTTPHeaders = [
            .accept(Constants.HTTP_HEADER_ACCEPT)
        ]
        
        print("URL signin : \(Config.URL_SIGNIN)")
        
        self.showProgressView = true
        AF.request(Config.URL_SIGNIN, method: .post, parameters: parameters, encoding: URLEncoding.default, headers: headers).responseJSON{(response) in
            self.showProgressView = false
            
            switch response.result {
                case .success:
                    let json = try? JSON(data: response.data!)
                    
                    print("json : \(json)")
                    
                    if json?["success"] ?? "" != false {
                        let dataService = DataService()
                        
                        if dataService.syncFromServer(json : json) {
                            
                            let now = Date()
                            let dateFormatter = DateFormatter()
                            dateFormatter.dateFormat = Constants.FORMAT_DATETIME_SERVICE
                            let dateOn = dateFormatter.string(from: now)
                            
                            var userLog = UserLogModel()
                            userLog.userUuid = appData.userUuid
                            userLog.activity = Constants.USER_LOG_ACTIVITY_SIGNIN
                            userLog.addedOn = dateOn
                            
                            let userLogDao = UserLogDao.sharedInstance
                            userLogDao.insert(record: userLog)
                            
                            var sync = SyncModel()
                            
                            var json = userLog.toJson()
                            json[Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME] = Constants.SYNC_ADAPTER_DATA_TYPE_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);
                            
                            appNavigation.pageActive = AppMainPage.home
        
  
                            
                            //self.goToMain = true
                        }
                    } else {
                        let message = json?["data"].string ?? ""
                        if !message.isEmpty {
                            self.titleAlert = Config.LANG_ERROR_GENERIC_TITLE
                            self.messageAlert = message
                            self.presentAlert = true
                        }
                    }
                    
                   return
                            
                case .failure :
                    self.titleAlert = Config.LANG_ERROR_COMMUNICATION_TITLE
                    self.messageAlert = Config.LANG_ERROR_COMMUNICATION_MESSAGE
                    self.presentAlert = true
                    
                    return
            }
            

           
         
            /*
            switch response.result {
                case .success:
                    
                   
                    print("Response Data : \(response.data!) ")
                    
                    let json = try? JSON(data: response.data!)
                    if json?["success"] ?? "" != false {
                        let dataService = DataService()
                        
                        if dataService.syncFromServer(json : json) {
                            self.goToMain = true
                        }
                    } else {
                        let message = json?["data"].string ?? ""
                        if !message.isEmpty {
                            self.titleAlert = "Error"
                            self.messageAlert = message
                            self.presentAlert = true
                        }
                    }
                    
            
                    return

                case .failure:
                    self.titleAlert = "Servidor no encontrado"
                    self.messageAlert = "Ocurrio un error de comunicación"
                    self.presentAlert = true
                    
                    return
            }*/
        }
    }

    
    private func validate() -> Bool
    {

        print("validate - email : \(email)")
        print("validate - password : \(password)")
        

        if email.isEmpty {
            self.isValidEmail = false
        } else  if !checkEmail(email: email) {
            self.isValidEmail = false
        } else {
            self.isValidEmail = true
        }
        
     
        
        if password.isEmpty {
            self.isValidPassword = false
        } else if(!checkPassword(password: password)) {
            self.isValidPassword = false
           
        } else {
            self.isValidPassword = true
        }
        
        return  self.isValidEmail &&  self.isValidPassword
    }
    

    private func checkEmail(email : String) -> Bool {
        let regex = #"^[a-zA-Z0-9_\-\.~]{2,}@[a-zA-Z0-9_\-\.~]{2,}\.[a-zA-Z]{2,}$"#

        let predicate = NSPredicate(format: "SELF MATCHES %@", regex)
        return predicate.evaluate(with: email) ? true : false;
    }

    private func checkPassword(password : String) -> Bool {
        let regexOld = #"^(?=.*\d+)(?=.*[a-z])(?=.*[A-Z])[0-9a-zA-Z]{6,16}$"#
        let regexNew = #"^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[\#\?\!\@\$\^\%\*\-]).{6,16}$"#

        let predicateNew = NSPredicate(format: "SELF MATCHES %@", regexNew)
        let predicateOld = NSPredicate(format: "SELF MATCHES %@", regexOld)
        if(predicateOld.evaluate(with: password)) {
            return true
        } else  if(predicateNew.evaluate(with: password)) {
            return true
        } else {
            return false
        }
    }
       

}



struct SigninView_Previews: PreviewProvider {
    static var previews: some View {
        SigninView()
    }
}

struct HeaderGroupView: View {

    
    var body: some View {
        //Inicio Logo
        HStack {
            Image("logo")
            .resizable()
            .frame(width: 50, height: 50)
                      
            Text(Config.LANG_SIGNIN_APP_NAME)
            .font(Font.custom(Config.FONT_NAME_BOLD, size: 24))
            .foregroundColor(Color("color_textview"))
                      
            Spacer()
        }
        .padding(.leading, 16)
        .padding(.top, 66)
        //Fin logo
        
        //Inicio Saludo
        HStack {
            Text(Config.LANG_SIGNIN_GREATING)
            .font(Font.custom(Config.FONT_NAME_BOLD, size: 32))
            .foregroundColor(Color("color_textview"))
            Spacer()
        }
        .padding(.leading, 16)
        .padding(.top, 10)
        //Fin Saludo
        
        //Inicio Encabezado
        HStack {
            Text(Config.LANG_SIGNIN_HEAD_LINE1)
            .font(Font.custom(Config.FONT_NAME_REGULAR, size: 16))
            .foregroundColor(Color("color_textview"))
            Spacer()
        }
        .padding(.leading, 16)
        .padding(.top, 10)
        //Fin Encabezado
    }
}

struct EmailTextFieldGroup : View {

    
    
    @Binding var email: String
    @Binding var isEditingEmail : Bool
    @Binding var isValidEmail : Bool
    
    @Binding var password: String
    @Binding var isEditingPassword: Bool
    @Binding var isValidPassword: Bool

    
    var body : some View {
        //Inicio Label Email
        HStack {
            Text(Config.LANG_SIGNIN_TITLE_EMAIL_FIELD)
            .font(Font.custom(Config  .FONT_NAME_REGULAR, size: 11))
            .foregroundColor(Color("color_textview"))
            Spacer()
        }
        .padding(.leading, 16)
        .padding(.top, 10)
        //Fin Label Email
        
        //Inicio TextField  Email
        
        Group {
            HStack {
                /*
                Image("ui_mail")
                .resizable()
                .frame(width: 24, height: 24)
                         .padding(.horizontal, 4)
                */
                
  
                TextField("",
                    text: self.$email,
                    onEditingChanged: { (changed) in
                        
                        if changed {
                            
                            if self.isEditingPassword {
                                self.isValidPassword = Validator.checkPassword(password: self.password)
                                self.isEditingPassword = false
                            }
                            
                            
                            self.isEditingEmail = true
                        } else {
                            self.isEditingEmail = false
                            self.isValidEmail = Validator.checkEmail(email: self.email)
                        }
                        
                    }, onCommit: {
                        self.isEditingEmail = false
                        self.isValidEmail = Validator.checkEmail(email: self.email)
                    }
                )
            
                .font(Font.custom(Config.FONT_NAME_REGULAR, size: 12))
                .textFieldStyle(PlainTextFieldStyle())
                .frame(height: 32)
                .keyboardType(.emailAddress)
                .autocapitalization(.none)
                //.foregroundColor(Color("color_textfield_foreground"))
                //.background(Color("color_textfield_background"))
                .padding(.leading, 4)
                Spacer()
           
            }
        }

        .foregroundColor(Color("color_textfield_foreground"))
        .background(Color("color_textfield_background"))
        .overlay(RoundedRectangle(cornerRadius: 5).stroke(
            Color(self.isEditingEmail ? "color_textfield_border_active" : self.isValidEmail ? "color_textfield_border" : "color_textfield_border_error" )
        ))
        .padding(.leading, 16)
        .padding(.trailing, 16)
        .padding(.top, self.isValidEmail ? 10 : 2)


        if !self.isValidEmail {
            HStack {
                Spacer()
             
                Text(Config.LANG_SIGNIN_ERROR_EMAIL_FIELD)
                .foregroundColor(.red)
                    .font(Font.custom(Config.FONT_NAME_REGULAR, size: 11))
             
            }
            .padding(.top, 5)
            .padding(.trailing, 16)
        }
        
        //Fin TextField Email
    }
    
}



struct PasswordTextFieldGroup : View {
    @Binding var password: String
    @Binding var isEditingPassword: Bool
    @Binding var isValidPassword: Bool
    @Binding var isPasswordShow: Bool

    var body : some View {
        //Inicio Label Password
        HStack {
            Text(Config.LANG_SIGNIN_TITLE_PASSWORD_FIELD)
            .font(Font.custom(Config  .FONT_NAME_REGULAR, size: 11))
            .foregroundColor(Color("color_textview"))
            Spacer()
        }
        .padding(.leading, 16)
        //Fin Label Password
        
        
        //Inicio TextField  Password
        
        Group {
            HStack {
                /*
                Image("ui_key")
                .resizable()
                .frame(width: 24, height: 24)
                         .padding(.horizontal, 4)
                 */
                if isPasswordShow {
                
                    TextField("",
                        text: self.$password,
                        onEditingChanged: { (changed) in
                            
                            if changed {
                                self.isEditingPassword = true
                            } else {
                                self.isEditingPassword = false
                                self.isValidPassword = Validator.checkPassword(password: self.password)
                            }
                            
                        }, onCommit: {
                            self.isEditingPassword = false
                            self.isValidPassword = Validator.checkPassword(password:  self.password)
                        }
                    )
                    .font(Font.custom(Config.FONT_NAME_REGULAR, size: 12))
                    .textFieldStyle(PlainTextFieldStyle())
                    .frame(height: 32)
                        .keyboardType(.default)
                    .autocapitalization(.none)
                    /*
                    .foregroundColor(Color("color_textfield_foreground"))
                    .background(Color("color_textfield_background"))
 */
                    .padding(.leading, 4)
                    Spacer()
                    
                    Button(action: {
                        self.isPasswordShow.toggle()
                    }, label: {
                        Image("ui_visibility_off")
                        .resizable()
                        .frame(width: 24, height: 24)
                                 .padding(.horizontal, 4)
                    })
                } else {
     
                    SecureField("", text: self.$password, onCommit: {
                        self.isEditingPassword = false
                        self.isValidPassword = Validator.checkPassword(password: self.password)
                    })
                    .onHover { hovering in
                        if hovering {
                            print("onHover")
                        } else {
                            print("offHover")
                        }
                                }
                    .onTapGesture {
                        self.isEditingPassword = true
                    }
                    .font(Font.custom(Config.FONT_NAME_REGULAR, size: 11))
                    .textFieldStyle(PlainTextFieldStyle())
                    .frame(height: 32)
                        .keyboardType(.default)
                    .autocapitalization(.none)
                    /*
                    .foregroundColor(Color("color_textfield_foreground"))
                    .background(Color("color_textfield_background"))*/
                        .padding(.leading, 4)
                    Spacer()
                    
                    Button(action: {
                        self.isPasswordShow.toggle()
                    }, label: {
                        Image("ui_visibility")
                        .resizable()
                        .frame(width: 24, height: 24)
                                 .padding(.horizontal, 4)
                        
                    })
                    
                }
                
                //
                //ui_visibility
           
            }
        }
        .foregroundColor(Color("color_textfield_foreground"))
        .background(Color("color_textfield_background"))
        .overlay(RoundedRectangle(cornerRadius: 5).stroke(
            Color(self.isEditingPassword ? "color_textfield_border_active" : self.isValidPassword ? "color_textfield_border" : "color_textfield_border_error" )
        ))
        .padding(.leading, 16)
        .padding(.trailing, 16)
        .padding(.top, 2)

        if !self.isValidPassword {
            HStack {
                Spacer()
             
                Text(Config.LANG_SIGNIN_ERROR_PASSWORD_FIELD)
                .foregroundColor(.red)
                    .font(Font.custom(Config.FONT_NAME_REGULAR, size: 11))
             
            }
            .padding(.top, 5)
            .padding(.trailing, 16)
        }
        
        //Fin TextField Password
        
        
    }
    
    

}

struct ButtonSignUpGroup : View {
    @Environment(\.openURL) var openURL

    
    var body : some View {
        Button(action: {
            openURL(URL(string: Config.URL_SIGNUP_ENDPOINT)!)
            
        }, label: {
            Text(Config.LANG_SIGNIN_BUTTON_SIGNUP)
             .font(Font.custom(Config.FONT_NAME_REGULAR, size: 13))
             .frame(width: UIScreen.main.bounds.width - 32, height: 35)
                .foregroundColor(Color("color_button_foreground"))
                .background(Color("color_button_background"))
                .border(Color("color_button_border"), width: Config.BUTTON_BORDER_SIZE)
                .cornerRadius(Config.BUTTON_BORDER_RADIUS)
            
        })
        .padding(.top, 16)
        .padding(.leading, 16)
        .padding(.trailing, 16)
    }
}

struct ButtonForgotPasswordGroup : View {
    @Environment(\.openURL) var openURL
    
    
    var body : some View {
        Button(action: {
            openURL(URL(string: Config.URL_FORGOT_PASSWORD_ENDPOINT)!)
            
        }, label: {
            Text(Config.LANG_SIGNIN_BUTTON_FORGOT_PASSWORD)
             .font(Font.custom(Config.FONT_NAME_REGULAR, size: 13))

                .foregroundColor(Color("color_button_foreground"))

               
            
        })
        .padding(.vertical, 16)
    }
}
Proyectos de Subversion Iphone Microlearning - Nuevo Interface

(root)/twogetskills/View/SigninView.swift – Rev 2
