@fto-consult/expo-ui 8.58.6 → 8.60.0

package/src/importer/validate.js

@@ -0,0 +1,137 @@
+import getSelectFieldValue from "./getSelectFieldValue";
+import appConfig from "$capp/config";
+
+export default function validate(args){
+    let {data,requiredFields,index,fields,table,tableText}= defaultObj(args)
+    data = defaultObj(data);
+    requiredFields = defaultArray(requiredFields);
+    if(!isObj(fields)) return "champs de validation incorects";
+    for(let i in fields){
+        let field = fields[i];
+        if(!isObj(field)) continue;
+        let code = defaultStr(i,field.code);
+        let label = defaultStr(field.label,field.text,i);
+        let v = data[code];
+        let isFieldSelected = arrayValueExists(requiredFields,code);
+        let type = defaultStr(field.type,'text').toLowerCase().trim();
+        let validType  = defaultStr(field.validType).toLowerCase();
+        let lSuffix = isNonNullString(tableText)? ("["+tableText+"]"):"";
+        let labelStr = (isNonNullString(v) || isNumber(v) ? (" la valeur <"+v+"> du champ ") : "le champ ")+label+lSuffix+"";
+        labelStr += (index)? (", ligne "+index):""
+        let isIdField = type == 'id' || type =="piece";
+
+        /**** les donées passés en paramètre de type tableau */
+        if(type.contains("select")){
+            if(field.multiple){
+                v = isArray(v)? v : (v?(v+""):"").split(",");
+            } else v = defaultStr(v);
+            let itemCodes = "";
+            let itemsL = Object.size((isObjOrArray(field.items)? field.items : [])) > 0 ? true : false;
+            let hasF = true;
+            let isSelectTableData = type == "selecttabledata";
+            if(isArray(v)){
+                let arr = [];
+                v.map((value)=>{
+                    if(itemsL){
+                        let _v = getSelectFieldValue({field,value});
+                        itemCodes = defaultStr(itemCodes,_v.itemCodes);
+                        if(_v.value !== false){
+                            arr.push(_v.value);
+                        }
+                    } else if(isNonNullString(value)) {
+                        arr.push(isSelectTableData? value.toUpperCase():value)
+                    }
+                });
+                hasF = arr.length > 0 ? true : false;
+                v = arr;
+            } else {
+                if(itemsL){
+                    let _v = getSelectFieldValue({field,value:v});
+                    itemCodes = _v.itemCodes;
+                    hasF = _v.value !== false? true : false;
+                    if(hasF){
+                        v = _v.value;
+                    }
+                }
+                if(isSelectTableData && hasF){
+                    v = v.toUpperCase();
+                }
+                //eif(isFieldSelected) console.log(hasF, code,_v,' is value');
+            }
+            if(isFieldSelected && !hasF && itemCodes){
+                return labelStr+" doit figurer parmi la liste : ["+itemCodes+"]";
+            } 
+        }
+
+        if((isIdField || validType.contains("required") || field.required)){
+            if(isIdField && isNonNullString(data.table)){
+            } else if(v == undefined || v == null || v =='' || (isArray(v) && v.length <= 0)) {
+                return labelStr+" est requis";
+            }
+        }
+        if(isIdField  && isNonNullString(v)){
+            v = v.trim();
+            if(!isValidDataFileName(v.replaceAll("/",""))) return labelStr+" a une valeur invalide";
+        }
+        if(type =="datafile" && v && !APP.DATA_FILE_MANAGER.get(v)){
+            return labelStr+ ", le "+APP.DATA_FILE_MANAGER.dataFileText+" "+defaultStr(v) +" est innexistant"
+        }
+        if((type =="number" || type=="decimal" || validType.contains("number") || validType.contains("decimal"))){
+            if(!isNumber(v)){
+                v = parseDecimal(v);
+                if(!isNumber(v) && isFieldSelected){
+                    return labelStr+" doit être un nombre";
+                } else {
+                    v = defaultDecimal(v);
+                }
+            }
+        }
+        
+        if(type =='email' && v && !isValidEmail(v,false)){
+            return labelStr+" doit être un email valide";
+        }
+        if(type == 'date' && v){
+            let date = APP.date.toDateObj(v,true);
+            if(!date || !date.date){
+                return labelStr+" doit être une date valide au format yyyy-mm-dd";
+            }
+        }
+        if(type == 'time' && v && !APP.date.isValidSQLTime(v)){
+            return labelStr+" doit être une heure valide au format hh:mm:ss";
+        }
+        
+        let strValid = labelStr+" doit être une chaine de caractère non nulle ";
+        if(isNumber(field.length) && isNonNullString(v) && v.length != field.length){
+            return strValid+" de "+field.length + " caractères";
+        }
+        if(isNumber(field.minLength) && isNonNullString(v) && v.length < field.minLength){
+            return strValid+" de "+field.minLength+" caractères minimum";
+        }
+        if(isNumber(field.maxLength) && isNonNullString(v) && v.length > field.maxLength){
+            return strValid+" de "+field.maxLength+" caractères maximum";
+        }
+        if(type =='switch'){
+            let checkedLabel = defaultStr(field.checkedLabel,code =='archived'?'Archivé':'Désactivé').toLowerCase().trim(),
+            uncheckedLabel = defaultStr(field.uncheckedLabel,code =='archived'?'Non archivé':'Activé').toLowerCase().trim(),
+            checkedValue = defaultVal(field.checkedValue,1),uncheckedValue = defaultVal(field.uncheckedValue,0)
+            v = (defaultVal(v,field.defaultValue,"")+"").toLowerCase().trim();
+            if(v == checkedValue+""){
+                v = checkedValue;
+            } else if(v == uncheckedValue+""){
+                v = uncheckedValue;
+            } else if(v == checkedLabel){
+                v = checkedValue;
+            } else if(v == uncheckedLabel){
+                v = uncheckedValue;
+            } 
+            if(!arrayValueExists([checkedValue,uncheckedValue],v)){
+                return labelStr+" doit  l'une des valeur : "+checkedLabel+"/"+uncheckedLabel+"/"+checkedValue+"/"+uncheckedValue;
+            }
+        }
+        if(isFieldSelected && v !== undefined){
+            data[code] = v;
+        }
+    }
+    data["has-validate-content-imp"] = true;
+    return true;
+}

package/src/media/document.js

@@ -0,0 +1,55 @@
+import * as DocumentPicker from 'expo-document-picker';
+import {extendObj} from "$cutils";
+import notify from "$cnotify";
+
+export const mimeTypes = {
+    sql : "application/sql",
+    json : "application/json",
+    pdf : "application/pdf",
+    xlsx : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    image : "image/*",
+    xml : "application/xml",
+    csv : "text/csv",
+}
+/****
+    @param {object}, @see : https://docs.expo.dev/versions/latest/sdk/document-picker/#documentpickeroptions
+    for mimeTypes, @see : https://en.wikipedia.org/wiki/Media_type
+*/
+export const pickDocument = (options)=>{
+    options = extendObj({},{
+        copyToCacheDirectory : true,
+        multiple : false,
+        type : undefined,
+    },options);
+    return new Promise((resolve,reject)=>{
+        return DocumentPicker.getDocumentAsync(options).then(({canceled,...rest})=>{
+            if(canceled){
+                notify.error("Opération annulée par l'utilisateur");
+                return reject({canceled});
+            }
+            return resolve({canceled,...rest});
+        })
+    })
+}
+
+export const pickJSON = (options)=>{
+    return pickDocument(extendObj({},options,{
+        type : mimeTypes.json,
+    }));
+}
+export const pickCSV = (options)=>{
+    return pickDocument(extendObj({},options,{
+        type : mimeTypes.csv,
+    }));
+}
+export const pickPDF = (options)=>{
+    return pickDocument(extendObj({},options,{
+        type : mimeTypes.pdf
+    }));
+}
+
+export const pickSQL = (options)=>{
+    return pickDocument(extendObj({},options,{
+        type : mimeTypes.sql,
+    }));
+}

package/src/media/exports.js

@@ -0,0 +1,131 @@
+import {isObj,isBase64} from "$cutils";
+import notify from "$enotify";
+import Camera from "./camera";
+import {isMobileNative} from "$platform";
+import {getFilePickerOptions} from "./utils";
+import React from "react";
+
+let cameraRef = null;
+
+export {cameraRef}
+
+export const createCameraRef = ()=>{
+    const ref = React.useRef(null);
+    React.useEffect(()=>{
+        cameraRef = ref.current;
+    },[ref.current])
+    return ref;
+}
+
+import * as ImagePicker from 'expo-image-picker';
+
+export const MEDIA_TYPES = {
+    ALL : ImagePicker.MediaTypeOptions.All,
+    IMAGES : ImagePicker.MediaTypeOptions.Images,
+    VIDEOS : ImagePicker.MediaTypeOptions.Videos,
+}
+
+export {ImagePicker};
+
+export function checkPermission (method){
+    return new Promise((resolve,reject)=>{
+        (typeof method =="function" && method || ImagePicker.requestMediaLibraryPermissionsAsync)().then((r)=>{
+            if(isObj(r) && (r.granted || r.status =='granted')){
+                resolve(r);
+                return true;
+            } else {
+                reject(r);
+            }
+        }).catch((e)=>{
+            console.log(e," unable to grand media permission");
+            notify.error("Permission à l'accès aux médias refusée par l'utilisateur");
+            reject(e);
+        });
+    })
+}
+
+export * from "./utils";
+
+const prepareImageResult = (result)=>{
+    if(!isObj(result)) return result;
+    if(Array.isArray(result.assets) && isObj(result.assets[0])){
+        result = {
+            ...result,
+            ...result.assets[0],
+        }
+    }
+    result.dataURL = result.dataUrl = isBase64(result.base64) ? ('data:image/jpeg;base64,'+result.base64) : null;
+    return result;
+}
+
+/**** @see : https://docs.expo.dev/versions/latest/sdk/imagepicker/#imagepickeroptions 
+ *  form more options.
+ */
+export const pickImageOrVideo = (options)=>{
+    return checkPermission().then(()=>{
+        return new Promise((resolve,reject)=>{
+            ImagePicker.launchImageLibraryAsync(getFilePickerOptions(options)).then((result)=>{
+                if(!result.cancelled && !result.canceled) {
+                    resolve(prepareImageResult(result));
+                } else {
+                    notify.warning("Opération annulée par l'utilisateur");
+                    reject(result);
+                }
+                return null;
+            }).catch(reject);
+        })
+    })
+}
+
+export const pickImage = (options)=>{
+    options = defaultObj(options);
+    options.mediaTypes = ImagePicker.MediaTypeOptions.Images;
+    return pickImageOrVideo(options)
+}
+
+export const pickVideo = (options)=>{
+    options = defaultObj(options);
+    options.mediaTypes = ImagePicker.MediaTypeOptions.Videos;
+    return pickImageOrVideo(options)
+}
+
+export const nonZeroMin = function(args){
+    let arra = Array.prototype.slice.call(arguments,0).sort();
+    let min = 0;
+    for(let i in arra){
+       if(isNumber(arra[i]) && arra[i] > 0) {
+           if(min <= 0){
+             min = arra[i]
+           } else if(arra[i]< min ){
+              min = arra[i]
+           }
+       }
+    }
+    return min;
+};
+
+export {Camera};
+
+export async function canTakePhoto(){
+    if(!isMobileNative()) return false;
+    return true;
+}
+
+export const takePhoto = (options)=>{
+    return new Promise((resolve,reject)=>{
+        return checkPermission(ImagePicker.requestCameraPermissionsAsync).then((perm)=>{
+            options = {base64:true,...Object.assign({},options)}
+            return ImagePicker.launchCameraAsync({...getFilePickerOptions(options)}).then((result)=>{
+                if(!result.cancelled && !result.canceled) {
+                    resolve(prepareImageResult(result));
+                } else {
+                    notify.warning("Opération annulée par l'utilisateur");
+                    reject(result);
+                }
+                return null;
+            })
+        }).catch(reject);
+    })
+}
+
+export const takePicture = takePhoto;

package/src/media/index.js

@@ -1,131 +1 @@
-import {isObj,isBase64} from "$cutils";
-import notify from "$enotify";
-import Camera from "./camera";
-import {isMobileNative} from "$platform";
-import {getFilePickerOptions} from "./utils";
-import React from "react";
-
-let cameraRef = null;
-
-export {cameraRef}
-
-export const createCameraRef = ()=>{
-    const ref = React.useRef(null);
-    React.useEffect(()=>{
-        cameraRef = ref.current;
-    },[ref.current])
-    return ref;
-}
-
-import * as ImagePicker from 'expo-image-picker';
-
-export const MEDIA_TYPES = {
-    ALL : ImagePicker.MediaTypeOptions.All,
-    IMAGES : ImagePicker.MediaTypeOptions.Images,
-    VIDEOS : ImagePicker.MediaTypeOptions.Videos,
-}
-
-export {ImagePicker};
-
-export function checkPermission (method){
-    return new Promise((resolve,reject)=>{
-        (typeof method =="function" && method || ImagePicker.requestMediaLibraryPermissionsAsync)().then((r)=>{
-            if(isObj(r) && (r.granted || r.status =='granted')){
-                resolve(r);
-                return true;
-            } else {
-                reject(r);
-            }
-        }).catch((e)=>{
-            console.log(e," unable to grand media permission");
-            notify.error("Permission à l'accès aux médias refusée par l'utilisateur");
-            reject(e);
-        });
-    })
-}
-
-export * from "./utils";
-
-const prepareImageResult = (result)=>{
-    if(!isObj(result)) return result;
-    if(Array.isArray(result.assets) && isObj(result.assets[0])){
-        result = {
-            ...result,
-            ...result.assets[0],
-        }
-    }
-    result.dataURL = result.dataUrl = isBase64(result.base64) ? ('data:image/jpeg;base64,'+result.base64) : null;
-    return result;
-}
-
-/**** @see : https://docs.expo.dev/versions/latest/sdk/imagepicker/#imagepickeroptions 
- *  form more options.
- */
-export const pickImageOrVideo = (options)=>{
-    return checkPermission().then(()=>{
-        return new Promise((resolve,reject)=>{
-            ImagePicker.launchImageLibraryAsync(getFilePickerOptions(options)).then((result)=>{
-                if(!result.cancelled && !result.canceled) {
-                    resolve(prepareImageResult(result));
-                } else {
-                    notify.warning("Opération annulée par l'utilisateur");
-                    reject(result);
-                }
-                return null;
-            }).catch(reject);
-        })
-    })
-}
-
-export const pickImage = (options)=>{
-    options = defaultObj(options);
-    options.mediaTypes = ImagePicker.MediaTypeOptions.Images;
-    return pickImageOrVideo(options)
-}
-
-export const pickVideo = (options)=>{
-    options = defaultObj(options);
-    options.mediaTypes = ImagePicker.MediaTypeOptions.Videos;
-    return pickImageOrVideo(options)
-}
-
-export const nonZeroMin = function(args){
-    let arra = Array.prototype.slice.call(arguments,0).sort();
-    let min = 0;
-    for(let i in arra){
-       if(isNumber(arra[i]) && arra[i] > 0) {
-           if(min <= 0){
-             min = arra[i]
-           } else if(arra[i]< min ){
-              min = arra[i]
-           }
-       }
-    }
-    return min;
-};
-
-export {Camera};
-
-export async function canTakePhoto(){
-    if(!isMobileNative()) return false;
-    return true;
-}
-
-export const takePhoto = (options)=>{
-    return new Promise((resolve,reject)=>{
-        return checkPermission(ImagePicker.requestCameraPermissionsAsync).then((perm)=>{
-            options = {base64:true,...Object.assign({},options)}
-            return ImagePicker.launchCameraAsync({...getFilePickerOptions(options)}).then((result)=>{
-                if(!result.cancelled && !result.canceled) {
-                    resolve(prepareImageResult(result));
-                } else {
-                    notify.warning("Opération annulée par l'utilisateur");
-                    reject(result);
-                }
-                return null;
-            })
-        }).catch(reject);
-    })
-}
-
-export const takePicture = takePhoto;
+export * from "./exports";