HRM-10/HRM.DA/Service/Recruitement/CVParserService.cs

803 lines
33 KiB
C#
Raw Normal View History

2026-11-03 13:06:00 +06:00
using System;
using System.Data;
using Ease.Core.Model;
using Ease.Core.DataAccess;
using Ease.Core;
using System.Collections.Generic;
using Ease.Core.Utility;
using HRM.BO;
using System.IO;
using System.Linq;
using HRM.BO.Basic;
using NPOI.SS.Formula.Functions;
using iTextSharp.text.pdf.parser;
using iTextSharp.text.pdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
//using static Org.BouncyCastle.Math.EC.ECCurve;
using System.Text.RegularExpressions;
using System.Text;
using UglyToad.PdfPig;
using UglyToad.PdfPig.Content;
using UglyToad.PdfPig.XObjects;
using static Microsoft.Extensions.Logging.EventSource.LoggingEventSource;
using Array = System.Array;
using NPOI.POIFS.Crypt.Dsig;
namespace HRM.DA
{
public class CVParserService
{
List<CvReaderAndExtractor> listItems = new List<CvReaderAndExtractor>();
const string MatchEmailPattern =
@"(([\w-]+\.)+[\w-]+|([a-zA-Z]{1}|[\w-]{2,}))@"
+ @"((([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\."
+ @"([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])){1}|"
+ @"([a-zA-Z]+[\w-]+\.)+[a-zA-Z]{2,4})";
public List<CvReaderAndExtractor> readPDF(IFormFileCollection files)
{
List<CvReaderAndExtractor> cvList = new List<CvReaderAndExtractor>();
try
{
int serial = 0;
foreach (var formFile in files)
{
CvReaderAndExtractor cv = new CvReaderAndExtractor();
cvList.Add(cv);
byte[] profilePictures = null;
StringBuilder text = new StringBuilder();
serial++;
var fileSize = formFile.Length;
var originalFile = formFile.FileName;
var fileExt = System.IO.Path.GetExtension(originalFile).Substring(1);
var fileName = formFile.FileName;
var ms = new MemoryStream();
formFile.CopyTo(ms);
cv.SerialId = serial;
cv.FileName = originalFile;
cv.ProfilePicByteArray = profilePictures;
cv.Ext = fileExt;
ExtractFile(cv, ms);
}
}
catch (Exception ex)
{
}
return cvList;
}
public void ExtractFile(CvReaderAndExtractor ocvitem, MemoryStream ms)
{
string errorText = "";
string base64String = "";
try
{
byte[] profilePictures = null;
StringBuilder text = new StringBuilder();
byte[] textAsBytes = ms.ToArray();
string fileType = null;
base64String = Convert.ToBase64String(textAsBytes);
ocvitem.FileAsByteArray = textAsBytes;
using (PdfReader pdfReader = new PdfReader(textAsBytes))
{
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
currentText = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currentText)));
text.Append(currentText);
}
}
var text1 = text.ToString();
string[] wordList = text1.Split(' ');
string tempPhoneNumber = null;
string tempEmail = null;
errorText = "Error in Extract Name:";
var name = extractNames(wordList, ocvitem);
ocvitem.Name = name;
errorText = "Error in Extract Mobile:";
tempPhoneNumber = extractMobile(wordList);
ocvitem.MobileNumber = tempPhoneNumber;
errorText = "Error in Extract Email:";
tempEmail = extractEamil(wordList);
ocvitem.Email = tempEmail;
errorText = "Error in Extract Education:";
var education = extractEducation(wordList);
ocvitem.Education = education;
errorText = "Error in Extract Experience:";
var experience = "";// extractExperience(wordList);
errorText = "Error in Extract Skill:";
var skill = "";//extractSkills(text1);
//var dateofBirth = "";
var dateofBirth = DateofBirth(wordList);
ocvitem.ProfilePicByteArray = profilePictures;
ocvitem.Ext = fileType;
ocvitem.Experience = experience;
ocvitem.Skill = skill;
ocvitem.BirthDate = dateofBirth;
}
catch (Exception ex)
{
var etext = (ex.Message.Length > 100) ? ex.Message.Substring(0, 50) : ex.Message;
errorText = errorText + " " + etext;
}
}
public void extractPicture(byte[] textAsBytes)
{
byte[] profilePictures = null;
string fileType = null;
using (MemoryStream pdfStream = new MemoryStream(textAsBytes)) // assuming pdfBytes is your byte array containing the PDF document
{
using (UglyToad.PdfPig.PdfDocument pdfDocument = UglyToad.PdfPig.PdfDocument.Open(pdfStream))
{
int imageCount = 1;
foreach (Page page in pdfDocument.GetPages())
{
List<XObjectImage> images = page.GetImages().Cast<XObjectImage>().ToList();
foreach (XObjectImage image in images)
{
byte[] imageRawBytes = image.RawBytes.ToArray();
if (imageRawBytes != null)
{
profilePictures = imageRawBytes;
fileType = GetFileType(imageRawBytes);
break;
}
imageCount++;
}
if (imageCount > 0)
{
break;
}
}
}
}
}
public string extractMobile(string[] wordList)
{
string tempPhoneNumber = null;
string numericPart = null;
for (var i = 0; i < wordList.Length; i++)
{
bool isNumber = false;
// mobile Number
if (string.IsNullOrEmpty(tempPhoneNumber))
{
if (!string.IsNullOrEmpty(wordList[i]))
{
if (wordList[i].Trim().Any(char.IsDigit))
{
var word = wordList[i];
numericPart = new string(wordList[i].Where(char.IsDigit).ToArray());
if (wordList[i].Trim().Contains('+'))
{
if (wordList[i].Trim().Contains('+') && wordList[i].Trim().Contains('('))
{
if (wordList[i].Trim().Contains('(') && wordList[i].Trim().Contains(')'))
{
var digitPart = wordList[i].Where(char.IsDigit).ToArray();
if (digitPart.Length == 13)
{
numericPart = new string(digitPart);
}
else
{
var digitPart1 = wordList[i + 1].Where(char.IsDigit).ToArray();
if ((digitPart.Length + digitPart1.Length) == 13)
{
numericPart = new string(digitPart) + new string(digitPart1);
}
}
}
numericPart = "+" + numericPart;
}
else
{
if ((wordList[i].Where(char.IsDigit).ToArray().Length) > 13)
{
int endIndex = Math.Min(13, wordList[i].Length);
numericPart = string.Join(" ", wordList[i], 0, endIndex);
}
numericPart = "+" + numericPart;
}
}
isNumber = true;
}
if (isNumber)
{
const string MatchPhonePattern = @"\b(\+?8801\d{9}|01\d{9})\b";
Regex rx = new Regex(MatchPhonePattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
MatchCollection matches = rx.Matches(numericPart);
int noOfMatches = matches.Count;
foreach (System.Text.RegularExpressions.Match match in matches)
{
tempPhoneNumber = match.Value.ToString();
}
if (tempPhoneNumber != null)
{
if (numericPart.Contains("+") && !tempPhoneNumber.Contains("+"))
{
tempPhoneNumber = "+" + tempPhoneNumber;
}
}
}
}
}
}
return tempPhoneNumber;
}
public string extractEamil(string[] wordList)
{
string tempEmail = null;
for (var i = 0; i < wordList.Length; i++)
{
bool isNumber = false;
if (wordList[i].Contains('@') && string.IsNullOrEmpty(tempEmail))
{
Regex rx = new Regex(
MatchEmailPattern,
RegexOptions.Compiled | RegexOptions.IgnoreCase);
MatchCollection matches = rx.Matches(wordList[i]);
int noOfMatches = matches.Count;
foreach (System.Text.RegularExpressions.Match match in matches)
{
tempEmail = match.Value.ToString();
}
}
}
return tempEmail;
}
public string DateofBirth(string[] wordList)
{
string tempBrith = "";
int index = -1;
for (var i = 0; i < wordList.Length; i++)
{
if (wordList[i].Contains("birth", StringComparison.OrdinalIgnoreCase))
{
index = i;
break;
// index = wordList[i].IndexOf("1");
//if(index == -1) index = wordList[i].IndexOf("2");
//if (index == -1) index = wordList[i].IndexOf("3");
//if (index == -1) index = wordList[i].IndexOf("4");
//if (index == -1) index = wordList[i].IndexOf("5");
//if (index == -1) index = wordList[i].IndexOf("6");
//if (index == -1) index = wordList[i].IndexOf("7");
//if (index == -1) index = wordList[i].IndexOf("8");
//if (index == -1) index = wordList[i].IndexOf("9");
//if (index != -1) tempBrith = wordList[i].Substring(index);
}
//if ((wordList[i].Contains("b", StringComparison.OrdinalIgnoreCase))
// && (wordList[i+1].Contains("i", StringComparison.OrdinalIgnoreCase))
// && (wordList[i+2].Contains("r", StringComparison.OrdinalIgnoreCase))
// && (wordList[i+3].Contains("t", StringComparison.OrdinalIgnoreCase))
// && (wordList[i+4].Contains("h", StringComparison.OrdinalIgnoreCase)))
// {
// index = i+5;
// break;
// }
}
if (index != -1)
{
for (var i = index+1; i < index +5; i++)
{
int intvlalue = 0;
if(int.TryParse(wordList[i][0].ToString(), out intvlalue))
{
tempBrith = wordList[i];
}
}
}
return tempBrith;
}
public string extractNames(string[] wordList, CvReaderAndExtractor ocvitem)
{
bool extratxWords = false;
bool newLineWords = false;
string extractingWords = "";
int count = 0;
for (var i = 0; i < wordList.Length; i++)
{
string currentWord = wordList[i].ToString().ToLower();
if (!string.IsNullOrEmpty(currentWord) && !string.IsNullOrWhiteSpace(currentWord))
{
if (currentWord.Contains("resume") || currentWord.Contains("cv"))
{
if (wordList[i + 1].ToString().ToLower().Contains("of")) // if resume of found then looking for next words
{
i++;
newLineWords = true;
continue;
}
}
else if (currentWord.Contains("name"))
{
extratxWords = true;
}
else if (newLineWords) // extended version of resume of
{
if (count > 0)
{
if (currentWord.Contains("\n")) //serching for next new line
{
int newlineIndex = currentWord.IndexOf('\n');
string wordsBeforeNewLine = wordList[i].Substring(0, newlineIndex);
extractingWords += " " + wordsBeforeNewLine;
break;
}
else
{
extractingWords += " " + wordList[i];
continue;
}
}
extractingWords += " " + wordList[i]; //just extracting next word and not checking new line
count++;
continue;
}
else
{
if (extratxWords == false)
{
extratxWords = true;
extractingWords += " " + wordList[i];
continue;
}
}
}
if (extratxWords && !newLineWords)
{
if (currentWord.Contains("\n")) //serching for next new line
{
int newlineIndex = currentWord.IndexOf('\n');
string wordsBeforeNewLine = wordList[i].Substring(0, newlineIndex);
extractingWords += " " + wordsBeforeNewLine;
extratxWords = false;
break;
}
else
{
extractingWords += " " + wordList[i]; //extracting words before finding the new line
}
}
}
bool checkValidation = false;
extractingWords = extractingWords.Trim();
if (extractingWords.Where(char.IsDigit).Any()) extractingWords = null;
if (newLineWords ==false && extractingWords != null && extractingWords !="")
{
var filenameSp = ocvitem.FileName.Split(' ');
var extractName = extractingWords.Split(' ');
for(int i =0;i< extractName.Length; i++ )
{
for (int j = 0; j < filenameSp.Length; j++)
{
if (extractName[i].ToLower() == filenameSp[j].ToLower())
{
checkValidation = true;
break;
}
}
}
}
if (checkValidation == false) extractingWords = null;
if (extractingWords == null)
{
string fileName = ocvitem.FileName;
fileName =fileName.Replace('(', ' ');
fileName = fileName.Replace(')', ' ');
fileName = fileName.Replace('1', ' ');
fileName = fileName.Replace('2', ' ');
fileName = fileName.Replace('3', ' ');
fileName = fileName.Replace('4', ' ');
fileName = fileName.Replace('5', ' ');
fileName = fileName.Replace('6', ' ');
fileName = fileName.Replace('7', ' ');
fileName = fileName.Replace('8', ' ');
fileName = fileName.Replace('9', ' ');
fileName = fileName.Replace('0', ' ');
fileName = fileName.Replace("Copy", "", true, null);
fileName = fileName.Replace("of", "", true, null);
fileName = fileName.Replace("cv", "", true, null);
fileName = fileName.Replace("Resume", "", true, null);
fileName = fileName.Replace(".pdf", "", true, null);
extractingWords = fileName.Trim();
}
return extractingWords;
}
public string extractExperience(string[] wordList)
{
string extractingWords = "";
bool isAllExtract = false;
bool isPrevWordWork = false;
bool isExperienceFound = false;
string[] next50Strings = null;
string[] experienceKeywords = { "experience", "experinces" };
for (var i = 0; i < wordList.Length; i++)
{
string currentWord = wordList[i].ToString().ToLower();
if (isPrevWordWork)
{
if (currentWord.Trim().Contains("experience") || currentWord.Trim().Contains("experiences"))
{
isExperienceFound = true;
continue;
}
}
if (!string.IsNullOrEmpty(currentWord) && !string.IsNullOrWhiteSpace(currentWord))
{
if (currentWord.Trim().Contains("work"))
{
if (currentWord.Trim().Contains("experience") || currentWord.Trim().Contains("experiences"))
{
isExperienceFound = true;
break;
}
else
{
isPrevWordWork = true;
continue;
}
}
if (isExperienceFound)
{
next50Strings = new string[Math.Min(200, wordList.Length - i)];
Array.Copy(wordList, i, next50Strings, 0, next50Strings.Length);
break;
}
}
}
int isDigitCount = 0;
bool istilwordfound = false;
string tillWords = null;
if (next50Strings != null)
{
for (var i = 0; i < next50Strings.Length; i++)
{
string currentWord = next50Strings[i].ToString().ToLower();
//if (currentWord.Trim().Contains("present"))
//{
// extractingWords += " " + next50Strings[i];
// for(var j = i; j < 5; j++)
// {
// extractingWords += " " + next50Strings[j];
// }
// istilwordfound = true;
// break;
//}
if (currentWord.Trim().Contains("till"))
{
tillWords += " " + next50Strings[i] + " " + next50Strings[i + 1];
for (var j = i; j < 5; j++)
{
tillWords += " " + next50Strings[j];
}
istilwordfound = true;
break;
}
else
{
tillWords += " " + next50Strings[i];
}
}
if (istilwordfound)
{
extractingWords = tillWords;
}
if (!istilwordfound)
{
string lastString = null;
List<string> digits = new List<string>();
foreach (string str in next50Strings)
{
if (str.ToString().ToLower().Contains("present"))
{
digits.Add(str);
}
var numericPart = new string(str.Where(char.IsDigit).ToArray());
if (!string.IsNullOrEmpty(numericPart))
{
digits.Add(numericPart);
}
}
if (digits != null && digits.Count > 0)
lastString = digits[digits.Count - 1];
if (!string.IsNullOrEmpty(lastString))
{
for (var i = 0; i < next50Strings.Length; i++)
{
string currentWord = next50Strings[i].ToString().ToLower();
if (currentWord.Trim().Contains(lastString))
{
extractingWords += " " + next50Strings[i];
bool isDigitinSameWord = false;
string extractingWords1 = null;
for (var j = i + 1; j < next50Strings.Length; j++)
{
string next = next50Strings[j].ToString().ToLower();
if (next.Trim().Contains(lastString))
{
isDigitinSameWord = true;
extractingWords1 += " " + next50Strings[j];
break;
}
else
{
extractingWords1 += " " + next50Strings[j];
}
}
if (isDigitinSameWord)
{
extractingWords = next50Strings + extractingWords1;
}
}
else
{
extractingWords += " " + next50Strings[i];
}
}
}
}
}
int index = extractingWords.IndexOf("education", StringComparison.OrdinalIgnoreCase);
if (index != -1)
{
extractingWords = extractingWords.Substring(0, index);
}
return extractingWords.Trim();
}
public string extractSkills(string input)
{
string extractWords = "";
int index = -1;
string targetWord = "";
if (input.ToLower().Contains("skill"))
{
if (input.ToLower().Contains("skills"))
{
index = input.ToLower().IndexOf("skills");
targetWord = "skills";
}
else if (input.ToLower().Contains("skill"))
{
index = input.ToLower().IndexOf("skill");
targetWord = "skill";
}
if (index != -1)
{
//int newlineIndex = input.IndexOf('\n', index);
// Extract the substring starting from the index of "MySql" to the next 200 characters
string result = input.Substring(index + targetWord.Length, Math.Min(500, input.Length - (index + targetWord.Length)));
string[] lines = result.Split('\n');
string[] firstFiveLines = new string[Math.Min(10, lines.Length)];
Array.Copy(lines, firstFiveLines, firstFiveLines.Length);
foreach (string line in firstFiveLines)
{
extractWords += line;
}
}
}
//if (input.ToLower().Contains("skills"))
//{
// int index = input.ToLower().IndexOf("skills");
// if (index != -1)
// {
// // Extract the substring starting from the index of "MySql" to the next 200 characters
// string result = input.Substring(index + "skills".Length, Math.Min(500, input.Length - (index + "skills".Length)));
// string[] lines = result.Split('\n');
// string[] firstFiveLines = new string[Math.Min(4, lines.Length)];
// Array.Copy(lines, firstFiveLines, firstFiveLines.Length);
// foreach (string line in firstFiveLines)
// {
// extractWords += line;
// }
// }
//}
return extractWords.Trim();
}
public string extractEducation(string[] wordList)
{
string extractingWords = "";
string[] educationalKeywords = { "education", "educational qualifications", "academic qualification", "academic" };
string[] extractingKeywords = { "secondary", "s.s.c", "ssc" };
int startindex = 0;
for (var i = 0; i < wordList.Length; i++)
{
string currentWord = wordList[i].ToString().ToLower();
if (!string.IsNullOrEmpty(currentWord) && !string.IsNullOrWhiteSpace(currentWord))
{
foreach (string keyword in educationalKeywords)
{
if (currentWord.Contains(keyword, StringComparison.CurrentCultureIgnoreCase))
{
if (currentWord.Trim().Contains("educational") || currentWord.Trim().Contains("education") || currentWord.Trim().Contains("academic"))
{
startindex = i;
break;
}
}
}
}
if (startindex != 0) break;
}
if (startindex == 0) return "";
int maxSearch = startindex + 100;
if (maxSearch > wordList.Length) maxSearch = wordList.Length;
int endIndex = 0;
for (var i = startindex + 1; i < maxSearch; i++)
{
string currentWord = wordList[i].ToString().ToLower();
if (!string.IsNullOrEmpty(currentWord) && !string.IsNullOrWhiteSpace(currentWord))
{
foreach (string keyword in extractingKeywords)
{
if (currentWord.Contains(keyword, StringComparison.OrdinalIgnoreCase))
{
endIndex = i;
break;
}
}
}
if (endIndex != 0) break;
}
if (endIndex != 0)
{
bool endfound = false;
for (var i = endIndex; i < endIndex + 15; i++)
{
if (i > wordList.Length) break;
string currentWord = wordList[i].ToString().ToLower();
if (!string.IsNullOrEmpty(currentWord) && !string.IsNullOrWhiteSpace(currentWord))
{
if (currentWord.Contains("\n"))
{
endfound = true;
endIndex = i;
break;
}
if(currentWord ==" " && wordList[i-1] ==" ")
{
endfound = true;
endIndex = i;
break;
}
}
}
if (endfound == false) endIndex = endIndex + 8;
}
else endIndex = startindex + 20;
extractingWords = "";
for (var i = startindex ; i < endIndex; i++)
{
extractingWords = extractingWords +" "+ wordList[i].ToString().ToLower();
}
// sl subject degree result institute passing year
// qualification:
// exam title concentration / major duration
extractingWords = extractingWords.Replace("sl", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("subject", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("degree", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("result", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("institute", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("passing", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("year", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("qualification", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("exam", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("concentration", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("/", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("major", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("duration", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("title", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("education", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("background", "", StringComparison.OrdinalIgnoreCase);
extractingWords = extractingWords.Replace("academic", "", StringComparison.OrdinalIgnoreCase);
int nIndex= extractingWords.IndexOf(':',0,20);
if(nIndex >0)
{
}
// invalid parse
if (extractingWords.Contains("university", StringComparison.OrdinalIgnoreCase) ==false
&& extractingWords.Contains("college", StringComparison.OrdinalIgnoreCase) == false
&& extractingWords.Contains("school", StringComparison.OrdinalIgnoreCase) == false)
{
extractingWords = "";
}
return extractingWords.Trim();
}
public static string GetFileType(byte[] bytes)
{
if (bytes == null || bytes.Length == 0)
{
return "Unknown";
}
// JPEG
if (bytes.Length >= 2 && bytes[0] == 0xFF && bytes[1] == 0xD8)
{
return "image/jpeg";
}
// PNG
if (bytes.Length >= 8 && bytes[0] == 0x89 && bytes[1] == 0x50 && bytes[2] == 0x4E && bytes[3] == 0x47 &&
bytes[4] == 0x0D && bytes[5] == 0x0A && bytes[6] == 0x1A && bytes[7] == 0x0A)
{
return "image/png";
}
// PDF
if (bytes.Length >= 4 && bytes[0] == 0x25 && bytes[1] == 0x50 && bytes[2] == 0x44 && bytes[3] == 0x46)
{
return "application/pdf";
}
// Add more checks for other file types as needed
return "Unknown";
}
}
}