Gecko [ gandhischool.edu.np ]

Name	Size	Permission
Date.json	2.81 MB	-rwxrwxr-x
ajax.tsx	3.73 KB	-rwxrwxr-x
constant.tsx	240 B	-rw-rw-r--
helper.tsx	8.92 KB	-rw-rw-r--
storage.tsx	4.11 KB	-rwxrwxr-x
url.tsx	1.5 KB	-rwxrwxr-x
utils.tsx	923 B	-rwxrwxr-x

Code Editor : helper.tsx

import _ from 'lodash';
import React = require('react');
export const currentTimeZone = new Date();
let dateArray = require('./Date.json');

var JSZip = require('jszip');
const Moment = require('moment');
const MomentRange = require('moment-range');
const moment = MomentRange.extendMoment(Moment);

export const timeConvertion = time => {
  let date = new Date(); // creates a Date Object using the clients current time
  let [hours, minutes, seconds] = time.split(':'); // using ES6 destructuring
  date.setHours(+hours); // set the hours, using implicit type coercion
  date.setMinutes(minutes); // you can pass Number or String, it doesn't really matter
  date.setSeconds(seconds);
  return date;
};

export const numberFormat = number => {
  if (number) return parseFloat(number).toFixed(2);
  return '0.00';
};

export const filterOnlyTrueArray = array => {
  let filteredObj = Object.keys(array).reduce((p, c) => {
    if (array[c]) p[c] = array[c];
    return p;
  }, {});
  return filteredObj;
};

//Compare two array value
export const objectsEqual = (o1, o2) =>
  typeof o1 === 'object' && Object.keys(o1).length > 0
    ? Object.keys(o1).length === Object.keys(o2).length &&
      Object.keys(o1).every(p => objectsEqual(o1[p], o2[p]))
    : o1 === o2;

export const arraysEqual = (a1, a2) =>
  a1.length === a2.length && a1.every((o, idx) => objectsEqual(o, a2[idx]));

//Check empty value
export const checkEmpty = item => {
  if (item) return item;
  else return 'N/A';
};

//Check empty date
// export function checkEmptyDate(date,format){
//     if(date) return moment.utc(date).tz(currentTimeZone).format(format);
//     else return "N/A";
// }

//Remove empty parameter
export function removeURLParameter(url, parameter) {
  var urlparts = url.split('?');
  if (urlparts.length >= 2) {
    var prefix = encodeURIComponent(parameter) + '=';
    var pars = urlparts[1].split(/[&;]/g);

//reverse iteration as may be destructive
    for (var i = pars.length; i-- > 0; ) {
      //idiom for string.startsWith
      if (pars[i].lastIndexOf(prefix, 0) !== -1) {
        pars.splice(i, 1);
      }
    }

url = '?' + pars.join('&');
    return url;
  } else {
    return url;
  }
}

//WORD COUNT
export function wordCountHelper(value) {
  let regex = /\s+/gi;
  let wordCount = value.trim().replace(regex, ' ').split(' ').length;
  let totalChars = value.length;
  let charCount = value.trim().length;
  let charCountNoSpace = value.replace(regex, '').length;
  return {
    wordCount: wordCount,
    totalChars: totalChars,
    charCount: charCount,
    charCountNoSpace: charCountNoSpace,
  };
}

//UNZIP FILE
export function unZipFile(file) {
  let zip = new JSZip();
  let newFile = [];
  let otherFile = 0;
  let totalFile = 0;

zip.loadAsync(file).then(function (zip) {
    // const re = /(.jpg|.png|.gif|.ps|.jpeg)$/;
    const re = /(.mp4|.mpeg|.wmv|.mp5|.mov)$/;
    Object.keys(zip.files).forEach(function (filename) {
      zip.files[filename].async('nodebuffer').then(function (fileData) {
        const extention = re.test(filename.toLowerCase());
        if (filename.includes('_MAC') || !extention) void 0;
        else {
          let bloblextracted = new File([fileData], filename);
          const format = {
            lastModified: bloblextracted.lastModified,
            name: bloblextracted.name,
            size: bloblextracted.size,
            type: bloblextracted.type,
          };
          newFile.push(format);
          totalFile += 1;
        }
      });
    });
  });

return newFile;
}

//GET BASE 64
export function getBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () =>
      resolve({
        result: reader.result,
        file_name: file.name,
        file_type: file.type,
        file_size: file.size,
      });
    reader.onerror = error => reject(error);
  });
}

//Is Valid Url
export function isValidURL(string) {
  var res = string.match(
    /(http(s)?:\/\/.)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/g,
  );
  return res !== null;
}

export function replaceObjectFromArray(collection, identity, replacement) {
  var index = _.indexOf(collection, _.find(collection, identity));
  collection.splice(index, 1, replacement);
}

export function getNepaliDate(date, format = '/') {
  const filter = _.filter(
    dateArray,
    item => item.ad_date === moment(date).format('YYYY/MM/DD'),
  );
  if (filter.length > 0) {
    let npDate = filter[0]['bs_date'];
    return npDate.replaceAll('/', format);
  } else date;
}

export function getEnglishDate(date) {
  let newDate = date;
  if (date.includes('-')) {
    newDate = date.replaceAll('-', '/');
  }
  const filter = _.filter(dateArray, item => item.bs_date === newDate);
  if (filter.length > 0) return filter[0]['ad_date'];
  else date;
}

export const getDateRanges = (st, ed) => {
  let start = new Date(st);
  let end = new Date(ed);

let range = moment().range(start, end);

return Array.from(range.by('days'));
};

export const getNumerToWord = num => {
 const single = [
 'Zero',
 'One',
 'Two',
 'Three',
 'Four',
 'Five',
 'Six',
 'Seven',
 'Eight',
 'Nine',
 ];
 const double = [
 'Ten',
 'Eleven',
 'Twelve',
 'Thirteen',
 'Fourteen',
 'Fifteen',
 'Sixteen',
 'Seventeen',
 'Eighteen',
 'Nineteen',
 ];
 const tens = [
 '',
 'Ten',
 'Twenty',
 'Thirty',
 'Forty',
 'Fifty',
 'Sixty',
 'Seventy',
 'Eighty',
 'Ninety',
 ];
 const formatTenth = (digit, prev) => {
 return 0 == digit ? '' : ' ' + (1 == digit ? double[prev] : tens[digit]);
 };
 const formatOther = (digit, next, denom) => {
 return (
 (0 != digit && 1 != next ? ' ' + single[digit] : '') +
 (0 != next || digit > 0 ? ' ' + denom : '')
 );
 };
 let res = '';
 let index = 0;
 let digit = 0;
 let next = 0;
 let words = [];
 if (((num += ''), isNaN(parseInt(num)))) {
 res = '';
 } else if (parseInt(num) > 0 && num.length <= 10) {
 for (index = num.length - 1; index >= 0; index--)
 switch (
 ((digit = num[index] - 0),
 (next = index > 0 ? num[index - 1] - 0 : 0),
 num.length - index - 1)
 ) {
 case 0:
 words.push(formatOther(digit, next, ''));
 break;
 case 1:
 words.push(formatTenth(digit, num[index + 1]));
 break;
 case 2:
 words.push(
 0 != digit
 ? ' ' +
 single[digit] +
 ' Hundred' +
 (0 != num[index + 1] && 0 != num[index + 2] ? ' and' : '')
 : '',
 );
 break;
 case 3:
 words.push(formatOther(digit, next, 'Thousand'));
 break;
 case 4:
 words.push(formatTenth(digit, num[index + 1]));
 break;
 case 5:
 words.push(formatOther(digit, next, 'Lakh'));
 break;
 case 6:
 words.push(formatTenth(digit, num[index + 1]));
 break;
 case 7:
 words.push(formatOther(digit, next, 'Crore'));
 break;
 case 8:
 words.push(formatTenth(digit, num[index + 1]));
 break;
 case 9:
 words.push(
 0 != digit
 ? ' ' +
 single[digit] +
 ' Hundred' +
 (0 != num[index + 1] || 0 != num[index + 2]
 ? ' and'
 : ' Crore')
 : '',
 );
 }
 res = words.reverse().join('') + ' Only/-';
 } else res = '';
 return res;
};

export const dateAgo = (start, end) => {
  let startDate: any = new Date(start);
  let endDate: any = new Date(end);
  let diffDate: any = new Date(endDate - startDate);

const year = diffDate.toISOString().slice(0, 4) - 1970;
  const month = diffDate.getMonth();
  const day = diffDate.getDate() - 1;

const res = {
    year: Number.isFinite(year) ? year : 0,
    month: Number.isFinite(month) ? month : 0,
    day: Number.isFinite(day) ? day : 0,
  };
  let format = '';
  if (year > 0) format += year + 'years';
  if (month > 0) format += month + 'months';
  if (day > 0) format += day + 'days';
  return format;
};

export function getReactSelectedValue(data, value) {
  return (
    data?.length > 0 &&
    data
      .filter(item => item.value == value)
      .map(({ value, label }) => ({
        value: value,
        label: label,
      }))
  );
}

export function renderStatus(data: any, batch: any) {
 try {
 let isBefore = moment(data?.start_date_ad).isBefore(
 moment(batch?.start_date_ad).toDate(),
 );
 let isAfter = moment(data?.start_date_ad).isAfter(
 moment(batch?.start_date_ad).toDate(),
 );
 if (+data?.is_current === 1)
 return Current;
 if (isBefore)
 return Previous ;
 if (isAfter) return New;
 } catch (e) {}
}

${this.title}

Code Editor : helper.tsx