696 lines
29 KiB
C#
696 lines
29 KiB
C#
using AutoMapper;
|
|
using HRM.DA;
|
|
using HRM.UI.DTOs.Auth;
|
|
using Microsoft.AspNetCore.Hosting;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.IdentityModel.Tokens;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IdentityModel.Tokens.Jwt;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Security.Claims;
|
|
using System.Security.Cryptography;
|
|
using System.Threading.Tasks;
|
|
using HRM.BO;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using System.Net.Http;
|
|
|
|
using Newtonsoft.Json;
|
|
using System.Net;
|
|
using System.Net.Http.Headers;
|
|
using System.Collections;
|
|
using Microsoft.AspNetCore.StaticFiles;
|
|
using Novacode;
|
|
using static HRM.BO.RecJobTracking;
|
|
|
|
//using Xceed.Words.NET;
|
|
//using Novacode;
|
|
|
|
namespace HRM.UI.Controllers
|
|
{
|
|
[ApiController]
|
|
[Route("api/filemanager")]
|
|
[Authorize]
|
|
public class FileManagerController : ControllerBase
|
|
{
|
|
private ISystemConfigaration _sysConfig;
|
|
private readonly IInternalRecruitmentService _internalRecruitmentService;
|
|
private readonly ICandidateService _candidateService;
|
|
private readonly ICVService _cvService;
|
|
private readonly IErCVService _ercvService;
|
|
private readonly IErAppliedApplicantService _erAppliedApplicantService;
|
|
private readonly IDepartmentService _departmentService;
|
|
private readonly IConfiguration _config;
|
|
private readonly IRecJobTrackingService _recJobTrackingService;
|
|
//private static string _filePath = @"ClientApp\Documents\";
|
|
//private static string _offerLetterfilePath = @"ClientApp\Documents\OfferLetter\";
|
|
private static string _filePath = @"Documents\";
|
|
private static string _offerLetterfilePath = @"Documents\OfferLetter\";
|
|
|
|
private static String[] units = { "Zero", "One", "Two", "Three",
|
|
"Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven",
|
|
"Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
|
|
"Seventeen", "Eighteen", "Nineteen" };
|
|
private static String[] tens = { "", "", "Twenty", "Thirty", "Forty",
|
|
"Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
|
|
// private static string _filePath = @"Documents\";
|
|
// private static string _offerLetterfilePath = @"Documents\OfferLetter\";
|
|
|
|
public FileManagerController(ISystemConfigaration sysConfig,
|
|
IInternalRecruitmentService internalRecruitmentService,
|
|
ICandidateService candidateService,
|
|
ICVService cvService, IDepartmentService departmentService, IErCVService ercvService, IErAppliedApplicantService erAppliedApplicantService,
|
|
IRecJobTrackingService recJobTrackingService,
|
|
IConfiguration config)
|
|
{
|
|
this._sysConfig = sysConfig;
|
|
_internalRecruitmentService = internalRecruitmentService;
|
|
_candidateService = candidateService;
|
|
_cvService = cvService;
|
|
_departmentService = departmentService;
|
|
_ercvService = ercvService;
|
|
_config = config;
|
|
_erAppliedApplicantService = erAppliedApplicantService;
|
|
_recJobTrackingService = recJobTrackingService;
|
|
}
|
|
|
|
[HttpPost("uploadConfigurationfile"), DisableRequestSizeLimit]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> uploadConfigurationfile()
|
|
{
|
|
try
|
|
{
|
|
var files = Request.Form.Files;
|
|
var uploadedFileNames = new List<string>();
|
|
string result = string.Empty;
|
|
int uploadID = Convert.ToInt32(Request.Form["fileTypeid"]);
|
|
|
|
long size = files.Sum(f => f.Length);
|
|
foreach (var formFile in files)
|
|
{
|
|
List<SystemConfigaration> configurations =
|
|
this._sysConfig.LoadXMLtoObject((EnumConfigurationType)uploadID, formFile.OpenReadStream());
|
|
this._sysConfig.Save(configurations, (EnumConfigurationType)uploadID); break;
|
|
}
|
|
|
|
return Ok();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
[HttpGet]
|
|
[Route("getSysConfiguration/{fileType}")]
|
|
public IActionResult getSysConfiguration(EnumConfigurationType fileType)
|
|
{
|
|
try
|
|
{
|
|
return Ok(this._sysConfig.Get(fileType));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpGet]
|
|
[Route("getConfigXmlFile/{fileType}")]
|
|
public IActionResult getConfigXmlFile(EnumConfigurationType fileType)
|
|
{
|
|
|
|
try
|
|
{
|
|
string stream = this._sysConfig.GetXMLFile(fileType);
|
|
|
|
return Ok(stream);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
[HttpPost("uploadExcelfile")]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> uploadExcelfile()
|
|
{
|
|
try
|
|
{
|
|
var files = Request.Form.Files;
|
|
List<UploaderItems> uploadedList = new List<UploaderItems>();
|
|
int i = 0;
|
|
int cntSuccess = 0;
|
|
var uploadedFileNames = new List<string>();
|
|
string result = string.Empty;
|
|
|
|
long size = files.Sum(f => f.Length);
|
|
foreach (var formFile in files)
|
|
{
|
|
var fileSize = formFile.Length;
|
|
var originalFile = formFile.FileName;
|
|
var generatedFile = Guid.NewGuid().ToString().Replace("-", "");
|
|
var uploaderItem = new UploaderItems();
|
|
uploaderItem.OriginalFileName = originalFile;
|
|
// uploaderItem.GeneratedFileName = generatedFile;
|
|
//var supportedTypes = new[] { "jpg", "png", "jpeg", "pdf" };
|
|
var fileExt = System.IO.Path.GetExtension(originalFile).Substring(1);
|
|
uploaderItem.GeneratedFileName = generatedFile + "." + fileExt;
|
|
//if (supportedTypes.Contains(fileExt))
|
|
//{
|
|
// if (fileSize > (500 * 1024))
|
|
// {
|
|
// result = "Maximum file size permitted is 500KB";
|
|
// throw new System.ArgumentException(result);
|
|
// }
|
|
//}
|
|
var fileName = _filePath + uploaderItem.OriginalFileName;
|
|
string fullPath = System.IO.Path.Combine(System.Environment.CurrentDirectory, fileName);
|
|
uploaderItem.Path = fullPath;
|
|
|
|
try
|
|
{
|
|
if (System.IO.File.Exists(fullPath))
|
|
{
|
|
System.IO.File.Delete(fullPath);
|
|
}
|
|
using (var stream = new FileStream(fullPath, FileMode.Create))
|
|
{
|
|
formFile.CopyTo(stream);
|
|
}
|
|
uploadedFileNames.Add(formFile.FileName);
|
|
uploadedList.Add(uploaderItem);
|
|
cntSuccess++;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
result = cntSuccess.ToString() + " files uploaded succesfully.<br/>";
|
|
|
|
result += "<ul>";
|
|
|
|
foreach (var f in uploadedFileNames)
|
|
{
|
|
result += "<li>" + f + "</li>";
|
|
}
|
|
|
|
result += "</ul>";
|
|
|
|
return Ok(uploadedList);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
[HttpPost("removeExcelfile")]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> removeExcelfile()
|
|
{
|
|
try
|
|
{
|
|
var files = Request.Form.Files;
|
|
List<UploaderItems> uploadedList = new List<UploaderItems>();
|
|
int i = 0;
|
|
int cntSuccess = 0;
|
|
var uploadedFileNames = new List<string>();
|
|
string result = string.Empty;
|
|
|
|
long size = files.Sum(f => f.Length);
|
|
foreach (var formFile in files)
|
|
{
|
|
var fileSize = formFile.Length;
|
|
var originalFile = formFile.FileName;
|
|
var fileExt = System.IO.Path.GetExtension(originalFile).Substring(1);
|
|
var fileName = _filePath + originalFile;
|
|
string fullPath = System.IO.Path.Combine(System.Environment.CurrentDirectory, fileName);
|
|
|
|
try
|
|
{
|
|
if (System.IO.File.Exists(fullPath))
|
|
{
|
|
System.IO.File.Delete(fullPath);
|
|
}
|
|
cntSuccess++;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
result = cntSuccess.ToString() + " files downloaded succesfully.<br/>";
|
|
result += "<ul>";
|
|
|
|
foreach (var f in uploadedFileNames)
|
|
{
|
|
result += "<li>" + f + "</li>";
|
|
}
|
|
|
|
result += "</ul>";
|
|
return Ok(uploadedList);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPost("uploadFiles")]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> UploadFiles()
|
|
{
|
|
try
|
|
{
|
|
var files = Request.Form.Files;
|
|
List<UploaderItems> uploadedList = new List<UploaderItems>();
|
|
int i = 0;
|
|
int cntSuccess = 0;
|
|
var uploadedFileNames = new List<string>();
|
|
string result = string.Empty;
|
|
|
|
long size = files.Sum(f => f.Length);
|
|
foreach (var formFile in files)
|
|
{
|
|
var fileSize = formFile.Length;
|
|
var originalFile = formFile.FileName;
|
|
var uploaderItem = new UploaderItems();
|
|
uploaderItem.OriginalFileName = originalFile;
|
|
var fileExt = System.IO.Path.GetExtension(originalFile).Substring(1);
|
|
|
|
var fileName = _filePath + uploaderItem.OriginalFileName;
|
|
string fullPath = System.IO.Path.Combine(System.Environment.CurrentDirectory, fileName);
|
|
uploaderItem.Path = fullPath;
|
|
|
|
try
|
|
{
|
|
if (System.IO.File.Exists(fullPath))
|
|
{
|
|
System.IO.File.Delete(fullPath);
|
|
}
|
|
using (var stream = new FileStream(fullPath, FileMode.Create))
|
|
{
|
|
formFile.CopyTo(stream);
|
|
}
|
|
uploadedFileNames.Add(formFile.FileName);
|
|
uploadedList.Add(uploaderItem);
|
|
cntSuccess++;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
// throw ex;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
result = cntSuccess.ToString() + " files uploaded succesfully.<br/>";
|
|
|
|
result += "<ul>";
|
|
|
|
foreach (var f in uploadedFileNames)
|
|
{
|
|
result += "<li>" + f + "</li>";
|
|
}
|
|
|
|
result += "</ul>";
|
|
|
|
return Ok(uploadedList);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
[Route("get-word-file")]
|
|
public async Task<IActionResult> GetWordFile(dynamic data)
|
|
{
|
|
CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
|
|
List<Department> departments = new List<Department>();
|
|
departments = new DepartmentService().Get(EnumStatus.Regardless, (int)currentUser.PayrollTypeID);
|
|
EnumAgreementLetterStatus lettertype = EnumAgreementLetterStatus.None;
|
|
string contentType = "";
|
|
var newFilePath = "";
|
|
var existingFilePath = "";
|
|
var newfileName = "";
|
|
var fileName = "";
|
|
var originalFileName = "";
|
|
//var fileName = _offerLetterfilePath + "ContractualEmploymentAgreement.docx";
|
|
//var newfileName = _offerLetterfilePath + "ContractualEmploymentAgreementNew.docx";
|
|
//var existingFilePath = System.IO.Path.Combine(System.Environment.CurrentDirectory, fileName);
|
|
//var newFilePath = System.IO.Path.Combine(System.Environment.CurrentDirectory, newfileName);
|
|
string departmentName = "";
|
|
string parentDepartmentName = "";
|
|
string candidateAddress = "";
|
|
string candidateName = "";
|
|
string jobLocation = "";
|
|
string basicSalary = "";
|
|
string issueDate = "";
|
|
string joiningDate = "";
|
|
string fathersName = "";
|
|
string mothersName = "";
|
|
string gender = "";
|
|
string lineManagerDesignation = "";
|
|
string candidateDesignation = "";
|
|
string salaryInWords = "";
|
|
HttpResponseMessage response = null;
|
|
ErApplicantDoc erApplicantDoc = null;
|
|
|
|
try
|
|
{
|
|
if (data != null)
|
|
{
|
|
|
|
var tempdata = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
|
|
RecruitmentLetters item = new RecruitmentLetters();
|
|
item = (RecruitmentLetters)tempdata["data"].ToObject<RecruitmentLetters>();
|
|
lettertype = (EnumAgreementLetterStatus)Convert.ToInt16(tempdata["letterType"].ToObject<string>());
|
|
fileName = _offerLetterfilePath + (string)tempdata["existingFileName"].ToObject<string>();
|
|
originalFileName = (string)tempdata["existingFileName"].ToObject<string>();
|
|
newfileName = _offerLetterfilePath + (string)tempdata["newFileName"].ToObject<string>();
|
|
existingFilePath = System.IO.Path.Combine(System.Environment.CurrentDirectory, fileName);
|
|
newFilePath = System.IO.Path.Combine(System.Environment.CurrentDirectory, newfileName);
|
|
|
|
if (item != null)
|
|
{
|
|
InternalRecruitment recruitment = _internalRecruitmentService.Get(item.RequisitionID);
|
|
List<Candidate> candidates = new CandidateService().GetCanditates(item.RequisitionID);
|
|
if (lettertype == EnumAgreementLetterStatus.IssueLetter)
|
|
{
|
|
if (recruitment.DepartmentId > 0)
|
|
{
|
|
var department = departments?.Find(x => x.ID == recruitment.DepartmentId);
|
|
departmentName = department.Name;
|
|
if(department.ParentID != null)
|
|
parentDepartmentName = departments?.Find(x => x.ID == department.ParentID).Name;
|
|
var candidate = candidates?.Find(x => x.ID == item.CandidateID);
|
|
CV cv = _cvService.Get(candidate.CvID);
|
|
candidateAddress = cv.PresentAddress;
|
|
candidateName = cv.Name;
|
|
jobLocation = item.JobLocation;
|
|
basicSalary = String.Format("{0:0.##}", item.BasicSalary);
|
|
salaryInWords = ConvertAmount(double.Parse(basicSalary));
|
|
issueDate = item.IssueOfferDate != null ? Convert.ToDateTime(item.IssueOfferDate).ToString("dd-MM-yy") : null;
|
|
joiningDate = item.JoiningDate != null ? Convert.ToDateTime(item.JoiningDate).ToString("dd-MM-yy") : null;
|
|
|
|
//for eecruitment
|
|
|
|
ErCV ercv = _ercvService.Get((int)cv.ErCvID);
|
|
if(ercv != null)
|
|
{
|
|
erApplicantDoc = new ErApplicantDoc();
|
|
erApplicantDoc.UserID = ercv.UserID;
|
|
erApplicantDoc.DocType = EnumFileType.Word;
|
|
erApplicantDoc.UpdatedBy = EnumActorType.Admin;
|
|
erApplicantDoc.CreatedBy = currentUser.UserID;
|
|
ErAppliedApplicant erAppliedApplicant = _erAppliedApplicantService.GetApplicantInfoByUserID(item.RequisitionID, ercv.UserID);
|
|
erApplicantDoc.AppliedApplicantID = erAppliedApplicant.ID;
|
|
erApplicantDoc.Remarks = "File";
|
|
erApplicantDoc.JobID = erAppliedApplicant.JobID;
|
|
}
|
|
_recJobTrackingService.UpdateActualDate(item.RequisitionID, item.JoiningDate);
|
|
}
|
|
}
|
|
else if (lettertype == EnumAgreementLetterStatus.AcceptanceLetter)
|
|
{
|
|
var candidate = candidates?.Find(x => x.ID == item.CandidateID);
|
|
CV cv = _cvService.Get(candidate.CvID);
|
|
candidateAddress = cv.PresentAddress;
|
|
candidateName = cv.Name;
|
|
fathersName = item.FathersName;
|
|
mothersName = item.MothersName;
|
|
candidateDesignation = recruitment.DesignationName;
|
|
if (cv.Gender == EnumGender.Male)
|
|
{
|
|
gender = "son";
|
|
}
|
|
else if (cv.Gender == EnumGender.Female)
|
|
{
|
|
gender = "daughter";
|
|
}
|
|
|
|
lineManagerDesignation = item.LineManagerDesignation;
|
|
basicSalary = String.Format("{0:0.##}", item.BasicSalary);
|
|
salaryInWords = ConvertAmount(double.Parse(basicSalary));
|
|
issueDate = item.IssueOfferDate != null ? Convert.ToDateTime(item.IssueOfferDate).ToString("dd-MM-yy") : null;
|
|
joiningDate = item.JoiningDate != null ? Convert.ToDateTime(item.JoiningDate).ToString("dd-MM-yy") : null;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("No Data found");
|
|
}
|
|
|
|
FileInfo ossInfo = null;
|
|
string FindText = "";
|
|
string ReplaceText = "";
|
|
ossInfo = new FileInfo(newFilePath);
|
|
if (ossInfo.Exists)
|
|
{
|
|
ossInfo.Delete();
|
|
}
|
|
|
|
System.IO.File.Copy(existingFilePath, newFilePath, true);
|
|
var table = new Dictionary<string, string>();
|
|
//Hashtable table = new Hashtable();
|
|
//table.Clear();
|
|
if (lettertype == EnumAgreementLetterStatus.IssueLetter)
|
|
{
|
|
table.Add(TagOutputConstant.CandidateAddress, candidateAddress);
|
|
table.Add(TagOutputConstant.CandidateName, candidateName);
|
|
table.Add(TagOutputConstant.IssueDate, issueDate);
|
|
table.Add(TagOutputConstant.BasicSalary, basicSalary);
|
|
table.Add(TagOutputConstant.JobLocation, jobLocation);
|
|
table.Add(TagOutputConstant.ParentDeptName, parentDepartmentName);
|
|
table.Add(TagOutputConstant.DeptName, departmentName);
|
|
table.Add(TagOutputConstant.JoiningDate, joiningDate);
|
|
table.Add(TagOutputConstant.SalaryInWords, salaryInWords);
|
|
}
|
|
else if (lettertype == EnumAgreementLetterStatus.AcceptanceLetter)
|
|
{
|
|
table.Add(TagOutputConstant.CandidateAddress, candidateAddress);
|
|
table.Add(TagOutputConstant.CandidateName, candidateName);
|
|
table.Add(TagOutputConstant.FathersName, fathersName);
|
|
table.Add(TagOutputConstant.MothersName, mothersName);
|
|
table.Add(TagOutputConstant.LineManagerDesignation, lineManagerDesignation);
|
|
table.Add(TagOutputConstant.IssueDate, issueDate== null ? "": issueDate);
|
|
table.Add(TagOutputConstant.BasicSalary, basicSalary);
|
|
table.Add(TagOutputConstant.JoiningDate, joiningDate == null ? "": joiningDate);
|
|
table.Add(TagOutputConstant.Gender, gender);
|
|
table.Add(TagOutputConstant.CandidateDesig, candidateDesignation == null ? "" : candidateDesignation);
|
|
table.Add(TagOutputConstant.SalaryInWords, salaryInWords);
|
|
}
|
|
this.ReplaceWords(newFilePath, table);
|
|
|
|
Stream memory = new MemoryStream();
|
|
byte[] buffer = new byte[16 * 1024];
|
|
contentType = GetFileType(newfileName);
|
|
buffer = System.IO.File.ReadAllBytes(newFilePath);
|
|
var name = newfileName;
|
|
|
|
string connectionString = _config.GetSection("dbSettings").GetSection("SqlCommandConnection").Value;
|
|
if(erApplicantDoc != null)
|
|
{
|
|
erApplicantDoc.FileData = buffer;
|
|
erApplicantDoc.OriginalFileName = originalFileName;
|
|
_erAppliedApplicantService.Save(erApplicantDoc, connectionString);
|
|
}
|
|
return File(buffer, contentType, name);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//response = new HttpResponseMessage
|
|
//{
|
|
// StatusCode = HttpStatusCode.InternalServerError,
|
|
// Content = new StringContent(ex.Message)
|
|
|
|
//};
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
|
|
// return response;
|
|
}
|
|
[HttpGet]
|
|
[Route("GetAllChildrenByParentNode/{fileType}/{parentNode}")]
|
|
public IActionResult GetAllChildrenByParentNode(EnumConfigurationType fileType, string parentNode)
|
|
{
|
|
try
|
|
{
|
|
return Ok(this._sysConfig.GetAllChildrenByParentNode(fileType, parentNode));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
[HttpGet]
|
|
[Route("GetConpanyInfo")]
|
|
public IActionResult GetConpanyInfo()
|
|
{
|
|
try
|
|
{
|
|
return Ok(Convert.ToString(this._sysConfig.GetconfigValue(EnumConfigurationType.Logic, "system", "company")));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
[HttpPost]
|
|
[Route("get-file-type")]
|
|
[AllowAnonymous]
|
|
[IgnoreAntiforgeryToken]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public string GetFileType(string originalFileName)
|
|
{
|
|
//var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
|
|
//string fileName = (string)item["fileName"].ToObject<string>();
|
|
string fileName = originalFileName;
|
|
string contentType;
|
|
new FileExtensionContentTypeProvider().TryGetContentType(fileName, out contentType);
|
|
return contentType ?? "application/octet-stream";
|
|
}
|
|
|
|
[HttpGet]
|
|
[Route("GetLogicValue/{parent}/{child}")]
|
|
public IActionResult GetLogicValue(string parent, string child)
|
|
{
|
|
try
|
|
{
|
|
return Ok(Convert.ToString(this._sysConfig.GetconfigValue(EnumConfigurationType.Logic, parent, child)));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
|
|
}
|
|
}
|
|
public void ReplaceWords(string destFileName, Dictionary<string, string> tagValueHashTable)
|
|
{
|
|
object SaveChanges = true;
|
|
// if (_wordapp == null) OpenWordApplication();
|
|
|
|
object Missing = System.Reflection.Missing.Value;
|
|
|
|
try
|
|
{
|
|
object FileName = destFileName;
|
|
object ReadOnly = false;
|
|
object TrueBool = true;
|
|
object FalseBool = false;
|
|
object IsVisible = false;
|
|
|
|
string FindText = "";
|
|
string ReplaceText = "";
|
|
|
|
DocX docTemp = DocX.Load(destFileName);
|
|
var _Pair = (tagValueHashTable != null) ? tagValueHashTable : new Dictionary<string, string>();
|
|
foreach (string sKey in _Pair.Keys)
|
|
{
|
|
FindText = sKey;
|
|
ReplaceText = _Pair[sKey];
|
|
docTemp.ReplaceText(FindText, ReplaceText);
|
|
}
|
|
docTemp.Save();
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new Exception("Error: Could not read file from disk. Original error: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public static String ConvertAmount(double amount)
|
|
{
|
|
try
|
|
{
|
|
Int64 amount_int = (Int64)amount;
|
|
Int64 amount_dec = (Int64)Math.Round((amount - (double)(amount_int)) * 100);
|
|
if (amount_dec == 0)
|
|
{
|
|
return ConvertAccurate(amount_int) + " Only.";
|
|
}
|
|
else
|
|
{
|
|
return ConvertAccurate(amount_int) + " Point " + ConvertAccurate(amount_dec) + " Only.";
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// TODO: handle exception
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static String ConvertAccurate(Int64 i)
|
|
{
|
|
if (i < 20)
|
|
{
|
|
return units[i];
|
|
}
|
|
if (i < 100)
|
|
{
|
|
return tens[i / 10] + ((i % 10 > 0) ? " " + ConvertAccurate(i % 10) : "");
|
|
}
|
|
if (i < 1000)
|
|
{
|
|
return units[i / 100] + " Hundred"
|
|
+ ((i % 100 > 0) ? " And " + ConvertAccurate(i % 100) : "");
|
|
}
|
|
if (i < 100000)
|
|
{
|
|
return ConvertAccurate(i / 1000) + " Thousand "
|
|
+ ((i % 1000 > 0) ? " " + ConvertAccurate(i % 1000) : "");
|
|
}
|
|
if (i < 10000000)
|
|
{
|
|
return ConvertAccurate(i / 100000) + " Lakh "
|
|
+ ((i % 100000 > 0) ? " " + ConvertAccurate(i % 100000) : "");
|
|
}
|
|
if (i < 1000000000)
|
|
{
|
|
return ConvertAccurate(i / 10000000) + " Crore "
|
|
+ ((i % 10000000 > 0) ? " " + ConvertAccurate(i % 10000000) : "");
|
|
}
|
|
return ConvertAccurate(i / 1000000000) + " Arab "
|
|
+ ((i % 1000000000 > 0) ? " " + ConvertAccurate(i % 1000000000) : "");
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
public class UploaderItems
|
|
{
|
|
public string OriginalFileName { get; set; }
|
|
public string GeneratedFileName { get; set; }
|
|
public string Path { get; set; }
|
|
public bool IsNew { get; set; }
|
|
public int UploaderModule
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
} |