1 |
61381
|
k.triantaf
|
import {UrlSegment} from '@angular/router';
|
2 |
|
|
import {AbstractControl, ValidatorFn, Validators} from "@angular/forms";
|
3 |
|
|
|
4 |
|
|
export class Dates {
|
5 |
|
|
public static yearMin = 1800;
|
6 |
|
|
public static yearMax = (new Date().getFullYear()) + 10;
|
7 |
|
|
public static currentYear = (new Date().getFullYear());
|
8 |
|
|
|
9 |
|
|
public static isValidYear(yearString, yearMin = this.yearMin, yearMax = this.yearMax) {
|
10 |
|
|
// First check for the pattern
|
11 |
|
|
if (!/^\d{4}$/.test(yearString))
|
12 |
|
|
return false;
|
13 |
|
|
var year = parseInt(yearString, 10);
|
14 |
|
|
|
15 |
|
|
// Check the ranges of month and year
|
16 |
|
|
if (year < yearMin || year > yearMax)
|
17 |
|
|
return false;
|
18 |
|
|
return true;
|
19 |
|
|
}
|
20 |
|
|
|
21 |
|
|
//format YYYY-MM-DD
|
22 |
|
|
public static isValidDate(dateString: string) {
|
23 |
|
|
// First check for the pattern
|
24 |
|
|
if (!/^\d{4}\-\d{1,2}\-\d{1,2}$/.test(dateString))
|
25 |
|
|
return false;
|
26 |
|
|
|
27 |
|
|
// Parse the date parts to integers
|
28 |
|
|
var parts = dateString.split("-");
|
29 |
|
|
var day = parseInt(parts[2], 10);
|
30 |
|
|
var month = parseInt(parts[1], 10);
|
31 |
|
|
var year = parseInt(parts[0], 10);
|
32 |
|
|
if (!this.isValidYear(parts[0])) {
|
33 |
|
|
return false;
|
34 |
|
|
}
|
35 |
|
|
|
36 |
|
|
// Check the ranges of month and year
|
37 |
|
|
if (month == 0 || month > 12)
|
38 |
|
|
return false;
|
39 |
|
|
|
40 |
|
|
var monthLength = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
41 |
|
|
|
42 |
|
|
// Adjust for leap years
|
43 |
|
|
if (year % 400 == 0 || (year % 100 != 0 && year % 4 == 0))
|
44 |
|
|
monthLength[1] = 29;
|
45 |
|
|
|
46 |
|
|
// Check the range of the day
|
47 |
|
|
return day > 0 && day <= monthLength[month - 1];
|
48 |
|
|
|
49 |
|
|
}
|
50 |
|
|
|
51 |
|
|
public static getDateToday(): Date {
|
52 |
|
|
var myDate = new Date();
|
53 |
|
|
return myDate;
|
54 |
|
|
|
55 |
|
|
}
|
56 |
|
|
|
57 |
|
|
public static getDateToString(myDate: Date): string {
|
58 |
|
|
var date: string = myDate.getFullYear() + "-";
|
59 |
|
|
date += ((myDate.getMonth() + 1) < 10) ? "0" + (myDate.getMonth() + 1) : (myDate.getMonth() + 1);
|
60 |
|
|
date += "-";
|
61 |
|
|
date += (myDate.getDate() < 10) ? "0" + myDate.getDate() : myDate.getDate();
|
62 |
|
|
return date;
|
63 |
|
|
|
64 |
|
|
}
|
65 |
|
|
|
66 |
|
|
public static getDateXMonthsAgo(x: number): Date {
|
67 |
|
|
var myDate = new Date();
|
68 |
|
|
myDate.setMonth(myDate.getMonth() - x);
|
69 |
|
|
return myDate;
|
70 |
|
|
|
71 |
|
|
}
|
72 |
|
|
|
73 |
|
|
public static getDateXYearsAgo(x: number): Date {
|
74 |
|
|
var myDate = new Date();
|
75 |
|
|
myDate.setFullYear(myDate.getFullYear() - x);
|
76 |
|
|
return myDate;
|
77 |
|
|
|
78 |
|
|
}
|
79 |
|
|
|
80 |
|
|
public static getDateFromString(date: string): Date {
|
81 |
|
|
|
82 |
|
|
var myDate = new Date();
|
83 |
|
|
myDate.setFullYear(+date.substring(0, 4));
|
84 |
|
|
myDate.setMonth(((date.length > 5) ? (+date.substring(5, 7) - 1) : (0)));
|
85 |
|
|
myDate.setDate(((date.length > 8) ? (+date.substring(8, 11)) : (1)));
|
86 |
|
|
return myDate;
|
87 |
|
|
|
88 |
|
|
}
|
89 |
|
|
|
90 |
|
|
public static getDate(dateString: string): Date {
|
91 |
|
|
let date = new Date(dateString);
|
92 |
|
|
if (Object.prototype.toString.call(date) === "[object Date]") {
|
93 |
|
|
if (isNaN(date.getTime())) {
|
94 |
|
|
return null;
|
95 |
|
|
} else {
|
96 |
|
|
return date;
|
97 |
|
|
}
|
98 |
|
|
} else {
|
99 |
|
|
return null;
|
100 |
|
|
}
|
101 |
|
|
}
|
102 |
|
|
|
103 |
|
|
public static timeSince(date: Date) {
|
104 |
|
|
|
105 |
|
|
let seconds = Math.floor((new Date().getTime() - new Date(date).getTime()) / 1000);
|
106 |
|
|
|
107 |
|
|
let interval = seconds / (365*24*60*60);
|
108 |
|
|
|
109 |
|
|
if (interval > 1) {
|
110 |
|
|
let years = Math.floor(interval);
|
111 |
|
|
return (years > 1?(years + ' years ago'):'a year ago');
|
112 |
|
|
}
|
113 |
|
|
interval = seconds / (7*24*60*60);
|
114 |
|
|
if (interval > 1) {
|
115 |
|
|
let weeks = Math.floor(interval);
|
116 |
|
|
return (weeks > 1?(weeks + ' weeks ago'):'a week ago');
|
117 |
|
|
}
|
118 |
|
|
interval = seconds / (24*60*60);
|
119 |
|
|
if (interval > 1) {
|
120 |
|
|
let days = Math.floor(interval);
|
121 |
|
|
return (days > 1?(days + ' days ago'):'a day ago');
|
122 |
|
|
}
|
123 |
|
|
interval = seconds / (60*60);
|
124 |
|
|
if (interval > 1) {
|
125 |
|
|
let hours = Math.floor(interval);
|
126 |
|
|
return (hours > 1?(hours + ' hours ago'):'an hour ago');
|
127 |
|
|
}
|
128 |
|
|
interval = seconds / 60;
|
129 |
|
|
if (interval > 1) {
|
130 |
|
|
let minutes = Math.floor(interval);
|
131 |
|
|
return (minutes > 1?(minutes + ' minutes ago'):'a minute ago');
|
132 |
|
|
}
|
133 |
|
|
seconds = Math.floor(interval);
|
134 |
|
|
return (seconds > 1?(seconds + ' seconds ago'):' just now');
|
135 |
|
|
}
|
136 |
|
|
}
|
137 |
|
|
|
138 |
|
|
export class DOI {
|
139 |
|
|
|
140 |
|
|
public static getDOIsFromString(str: string): string[] {
|
141 |
|
|
return Identifier.getDOIsFromString(str);
|
142 |
|
|
}
|
143 |
|
|
|
144 |
|
|
public static isValidDOI(str: string): boolean {
|
145 |
|
|
return Identifier.isValidDOI(str);
|
146 |
|
|
}
|
147 |
|
|
}
|
148 |
|
|
|
149 |
|
|
export class Identifier {
|
150 |
|
|
class: "doi" | "pmc" | "pmid" | "handle" | "ORCID" = null;
|
151 |
|
|
id: string;
|
152 |
|
|
|
153 |
|
|
public static getDOIsFromString(str: string): string[] {
|
154 |
|
|
var DOIs: string[] = [];
|
155 |
|
|
var words: string[] = str.split(" ");
|
156 |
|
|
|
157 |
|
|
for (var i = 0; i < words.length; i++) {
|
158 |
|
|
if (DOI.isValidDOI(words[i]) && DOIs.indexOf(words[i]) == -1) {
|
159 |
|
|
DOIs.push(words[i]);
|
160 |
|
|
}
|
161 |
|
|
}
|
162 |
|
|
return DOIs;
|
163 |
|
|
}
|
164 |
|
|
|
165 |
|
|
public static getIdentifiersFromString(str: string): Identifier[] {
|
166 |
|
|
let identifiers: Identifier[] = [];
|
167 |
|
|
let words: string[] = str.split(" ");
|
168 |
|
|
|
169 |
|
|
for (let id of words) {
|
170 |
|
|
if (id.length > 0) {
|
171 |
|
|
let identifier: Identifier = this.getIdentifierFromString(id);
|
172 |
|
|
if (identifier) {
|
173 |
|
|
identifiers.push(identifier);
|
174 |
|
|
}
|
175 |
|
|
}
|
176 |
|
|
}
|
177 |
|
|
return identifiers;
|
178 |
|
|
}
|
179 |
|
|
|
180 |
|
|
public static getIdentifierFromString(pid: string,strict:boolean = true): Identifier {
|
181 |
|
|
if (Identifier.isValidDOI(pid)) {
|
182 |
|
|
return {"class": "doi", "id": pid};
|
183 |
|
|
} else if (Identifier.isValidORCID(pid)) {
|
184 |
|
|
return {"class": "ORCID", "id": pid};
|
185 |
|
|
} else if (Identifier.isValidPMCID(pid)) {
|
186 |
|
|
return {"class": "pmc", "id": pid};
|
187 |
|
|
} else if (Identifier.isValidPMID(pid)) {
|
188 |
|
|
return {"class": "pmid", "id": pid};
|
189 |
|
|
} else if (Identifier.isValidHANDLE(pid)) {
|
190 |
|
|
return {"class": "handle", "id": pid};
|
191 |
|
|
}
|
192 |
|
|
//set it as a doi, to catch the case that doi has not valid format
|
193 |
|
|
return (strict?null:{"class": "doi", "id": pid});
|
194 |
|
|
}
|
195 |
|
|
|
196 |
|
|
public static getResultPIDFromIdentifiers(identifiers: Map<string, string[]>): Identifier {
|
197 |
|
|
let classes:string [] = ["doi", "handle", "pmc", "pmid"];
|
198 |
|
|
if(identifiers) {
|
199 |
|
|
for (let cl of classes){
|
200 |
|
|
if(identifiers.get(cl)){
|
201 |
|
|
for (let pid of identifiers.get(cl)) {
|
202 |
|
|
let identifier = Identifier.getIdentifierFromString(pid);
|
203 |
|
|
if (identifier){
|
204 |
|
|
return identifier;
|
205 |
|
|
}
|
206 |
|
|
}
|
207 |
|
|
}
|
208 |
|
|
}
|
209 |
|
|
return null;
|
210 |
|
|
}
|
211 |
|
|
}
|
212 |
|
|
|
213 |
|
|
public static isValidDOI(str: string): boolean {
|
214 |
|
|
//keep only exp3?
|
215 |
|
|
let exp1 = /\b(10[.][0-9]{4,}(?:[.][0-9]+)*\/(?:(?!["&\'<>])\S)+)\b/g;
|
216 |
|
|
let exp2 = /\b(10[.][0-9]{4,}(?:[.][0-9]+)*\/(?:(?!["&\'<>])[[:graph:]])+)\b/g;
|
217 |
|
|
let exp3 = /\b(10[.]*)\b/g;
|
218 |
|
|
return (str.match(exp1) != null || str.match(exp2) != null || str.match(exp3) != null);
|
219 |
|
|
}
|
220 |
|
|
|
221 |
|
|
public static isValidORCID(str: string): boolean {
|
222 |
|
|
let exp = /\b\d{4}-\d{4}-\d{4}-(\d{3}X|\d{4})\b/g;
|
223 |
|
|
return str.match(exp) != null;
|
224 |
|
|
}
|
225 |
|
|
|
226 |
|
|
public static isValidPMID(str: string): boolean {
|
227 |
|
|
let exp = /^\d*$/g;
|
228 |
|
|
return str.match(exp) != null;
|
229 |
|
|
|
230 |
|
|
}
|
231 |
|
|
|
232 |
|
|
public static isValidPMCID(str: string): boolean {
|
233 |
|
|
let exp = /^(PMC\d{7})$/g;
|
234 |
|
|
return str.match(exp) != null;
|
235 |
|
|
}
|
236 |
|
|
|
237 |
|
|
public static isValidHANDLE(str: string): boolean {
|
238 |
|
|
let exp = /^[0-9a-zA-Z-]*\/[0-9a-zA-Z-]*$/g;
|
239 |
|
|
return str.match(exp) != null;
|
240 |
|
|
}
|
241 |
|
|
}
|
242 |
|
|
|
243 |
|
|
export class StringUtils {
|
244 |
|
|
|
245 |
|
|
public static urlRegex = 'https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|www\.' +
|
246 |
|
|
'[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9]+\.[^\s]{2,}|www\.' +
|
247 |
|
|
'[a-zA-Z0-9]+\.[^\s]{2,}';
|
248 |
|
|
|
249 |
|
|
public static urlPrefix(url: string): string {
|
250 |
|
|
if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) {
|
251 |
|
|
return "";
|
252 |
|
|
} else {
|
253 |
|
|
return "//";
|
254 |
|
|
}
|
255 |
|
|
}
|
256 |
|
|
|
257 |
|
|
public static quote(params: string): string {
|
258 |
|
|
return '"' + params + '"';
|
259 |
|
|
}
|
260 |
|
|
|
261 |
|
|
public static unquote(params: string): string {
|
262 |
|
|
if (params.length > 2 && (params[0] == '"' && params[params.length - 1] == '"') || (params[0] == "'" && params[params.length - 1] == "'")) {
|
263 |
|
|
params = params.substring(1, params.length - 1);
|
264 |
|
|
}
|
265 |
|
|
return params;
|
266 |
|
|
}
|
267 |
|
|
|
268 |
|
|
public static URIEncode(params: string): string {
|
269 |
|
|
return encodeURIComponent(params);
|
270 |
|
|
}
|
271 |
|
|
|
272 |
|
|
public static URIDecode(params: string): string {
|
273 |
|
|
return decodeURIComponent(params);
|
274 |
|
|
}
|
275 |
|
|
|
276 |
|
|
public static validateEmails(emails: string): boolean {
|
277 |
|
|
return (emails.split(',')
|
278 |
|
|
.map(email => Validators.email(<AbstractControl>{value: email.trim()}))
|
279 |
|
|
.find(_ => _ !== null) === undefined);
|
280 |
|
|
}
|
281 |
|
|
|
282 |
|
|
public static b64DecodeUnicode(str) {
|
283 |
|
|
return decodeURIComponent(Array.prototype.map.call(atob(str), function (c) {
|
284 |
|
|
return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
|
285 |
|
|
}).join(''));
|
286 |
|
|
}
|
287 |
|
|
|
288 |
|
|
private emailValidator(email: any): boolean {
|
289 |
|
|
return !!email.match("^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}$");
|
290 |
|
|
}
|
291 |
|
|
|
292 |
|
|
public static isValidUrl(url: string): boolean {
|
293 |
|
|
return new RegExp(this.urlRegex).test(url);
|
294 |
|
|
}
|
295 |
|
|
|
296 |
|
|
public static urlValidator(): ValidatorFn {
|
297 |
|
|
return Validators.pattern(StringUtils.urlRegex);
|
298 |
|
|
}
|
299 |
|
|
|
300 |
|
|
public static sliceString(mystr, size: number): string {
|
301 |
|
|
const sliced = String(mystr).substr(0, size);
|
302 |
|
|
return sliced + (String(mystr).length > size ? '...' : '');
|
303 |
|
|
}
|
304 |
|
|
|
305 |
|
|
/**
|
306 |
|
|
* Splits a text to words base on a list of separators. Returns the words of the text including the separators.
|
307 |
|
|
* DO NOT TOUCH, IT WORKS
|
308 |
|
|
*
|
309 |
|
|
* @param text
|
310 |
|
|
* @param separators
|
311 |
|
|
*/
|
312 |
|
|
public static split(text: string, separators: string[]): string[] {
|
313 |
|
|
let words: (string | string[])[] = [text];
|
314 |
|
|
separators.forEach(separator => {
|
315 |
|
|
words.forEach((word, index) => {
|
316 |
|
|
if (typeof word === "string" && separators.indexOf(word) === -1) {
|
317 |
|
|
let tokens: string[] = word.split(separator).filter(value => value !== '');
|
318 |
|
|
if (tokens.length > 1) {
|
319 |
|
|
words[index] = [];
|
320 |
|
|
tokens.forEach((token, i) => {
|
321 |
|
|
(<string[]>(words[index])).push(token);
|
322 |
|
|
if (i !== (tokens.length - 1)) {
|
323 |
|
|
(<string[]>(words[index])).push(separator);
|
324 |
|
|
}
|
325 |
|
|
});
|
326 |
|
|
}
|
327 |
|
|
}
|
328 |
|
|
});
|
329 |
|
|
words = [].concat.apply([], words);
|
330 |
|
|
});
|
331 |
|
|
return <string []>words;
|
332 |
|
|
}
|
333 |
|
|
|
334 |
|
|
public static capitalize(value: string): string {
|
335 |
|
|
return value.charAt(0).toUpperCase() + value.slice(1);
|
336 |
|
|
}
|
337 |
|
|
|
338 |
|
|
/**
|
339 |
|
|
* Checks if a text contains a word
|
340 |
|
|
*/
|
341 |
|
|
public static containsWord(text: string, word: string): boolean {
|
342 |
|
|
return (text && text.toLowerCase().includes(word));
|
343 |
|
|
}
|
344 |
|
|
|
345 |
|
|
public static URLSegmentsToPath(segments: UrlSegment[]): string {
|
346 |
|
|
let path = '';
|
347 |
|
|
segments.forEach(route => {
|
348 |
|
|
path += '/' + route.path;
|
349 |
|
|
})
|
350 |
|
|
return path;
|
351 |
|
|
}
|
352 |
|
|
|
353 |
|
|
public static isEuropeanCountry(country: string) {
|
354 |
|
|
let countries = ["Albania", "Andorra", "Armenia", "Austria", "Azerbaijan", "Belarus", "Belgium", "Bosnia and Herzegovina",
|
355 |
|
|
"Bulgaria", "Croatia", "Cyprus", "Czech Republic", "Denmark", "Estonia", "Finland", "France", "Georgia", "Germany", "Greece", "Hungary", "Iceland", "Ireland",
|
356 |
|
|
"Italy", "Kosovo", "Latvia", "Liechtenstein", "Lithuania", "Luxembourg", "Macedonia", "Malta", "Moldova", "Monaco", "Montenegro", "The Netherlands", "Norway", "Poland",
|
357 |
|
|
"Portugal", "Romania", "Russia", "San Marino", "Serbia", "Slovakia", "Slovenia", "Spain", "Sweden", "Switzerland", "Turkey", "Ukraine", "United Kingdom", "Vatican City",
|
358 |
|
|
];
|
359 |
|
|
return (country && countries.indexOf(country) != -1);
|
360 |
|
|
}
|
361 |
|
|
|
362 |
|
|
public static isOpenAIREID(id: string) {
|
363 |
|
|
if (id && id.length == 46) {
|
364 |
|
|
let exp1 = /^.{12}::([0-9a-z]{32})$/g;
|
365 |
|
|
return (id.match(exp1) != null);
|
366 |
|
|
}
|
367 |
|
|
return false;
|
368 |
|
|
}
|
369 |
|
|
public static HTMLToString( html:string){
|
370 |
|
|
try {
|
371 |
|
|
html = html.replace(/ /g, ' ');
|
372 |
|
|
html = html.replace(/(\r\n|\n|\r| +(?= ))|\s\s+/gm, " ");
|
373 |
|
|
html = html.replace(/<[^>]*>/g, '');
|
374 |
|
|
}catch( e){
|
375 |
|
|
}
|
376 |
|
|
return html;
|
377 |
|
|
}
|
378 |
|
|
}
|