public FormSubmitDetails UpdateFormDetails(string Instance, string SessionId, string Version, FormDetails FormDetails)
{
FormSubmitDetails formSubmitDetails = new FormSubmitDetails();
SICTLogger.WriteInfo(DepartureFormServices.CLASS_NAME, "UpdateFormDetails", "Start");
try
{
UserDetailsBusiness userDetailsBusiness = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
if (userDetailsBusiness.IsSessionIdValid(SessionId, false))
{
DepartureFormBusiness departureFormBusiness = new FactoryBusiness().GetDepartureFormBusiness(Version);
formSubmitDetails = departureFormBusiness.UpdateFormDetails(Instance, FormDetails, SessionId);
}
else
{
formSubmitDetails.ReturnCode = 0;
formSubmitDetails.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(DepartureFormServices.CLASS_NAME, "UpdateFormDetails", "Invalid session ");
}
}
catch (Exception ex)
{
formSubmitDetails.ReturnCode = -1;
formSubmitDetails.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(DepartureFormServices.CLASS_NAME, "UpdateFormDetails", ex);
}
SICTLogger.WriteInfo(DepartureFormServices.CLASS_NAME, "UpdateFormDetails", "End");
return(formSubmitDetails);
}
public bool CheckIsSpecialUserOrNot(string UserName)
{
bool IsSpecialUser = false;
try
{
string[] SUserList = System.Convert.ToString(ConfigurationManager.AppSettings["SpecialUsers"]).Split(new char[]
{
','
});
string[] array = SUserList;
for (int i = 0; i < array.Length; i++)
{
string s = array[i];
if (s.Equals(UserName, System.StringComparison.OrdinalIgnoreCase))
{
IsSpecialUser = true;
break;
}
}
}
catch (System.Exception Ex)
{
SICTLogger.WriteException(UserDetailsBusiness.CLASS_NAME, "CheckIsSpecialUserOrNot", Ex);
}
return(IsSpecialUser);
}
public ReturnValue DeleteFormDetails(string Instance, string SessionId, string Version, string FormId)
{
ReturnValue returnValue = new ReturnValue();
SICTLogger.WriteInfo(DepartureFormServices.CLASS_NAME, "DeleteFormDetails", "Start");
try
{
UserDetailsBusiness userDetailsBusiness = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
if (userDetailsBusiness.IsSessionIdValid(SessionId, false))
{
DepartureFormBusiness departureFormBusiness = new FactoryBusiness().GetDepartureFormBusiness(Version);
returnValue = departureFormBusiness.DeleteFormDetails(Convert.ToInt32(FormId));
}
else
{
returnValue.ReturnCode = 0;
returnValue.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(DepartureFormServices.CLASS_NAME, "DeleteFormDetails", "Invalid session ");
}
}
catch (Exception ex)
{
returnValue.ReturnCode = -1;
returnValue.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(DepartureFormServices.CLASS_NAME, "DeleteFormDetails", ex);
}
new AuditLogBusiness().DeleteFormEntryAuditLog(Convert.ToBoolean(returnValue.ReturnCode), SessionId, Convert.ToInt32(FormId));
SICTLogger.WriteInfo(DepartureFormServices.CLASS_NAME, "DeleteFormDetails", "End");
return(returnValue);
}
public ReturnValue CreateTargetVsCompletesCacheFiles(string SessionId)
{
const string FUNCTION_NAME = "CreateTargetVsCompletesCacheFiles";
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
ReturnValue ReturnValue = new ReturnValue();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for SessionId - " + SessionId);
try
{
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
DashboardBusiness ObjDashboardBusiness = new FactoryBusiness().GetDashboardBusiness(BusinessConstants.VERSION_BASE);
ObjDashboardBusiness.CreateCacheFileforTargetVsCompletesCharts();
}
else
{
ReturnValue.ReturnCode = 0;
ReturnValue.ReturnMessage = "Session InValid";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for SessionId- " + SessionId);
return(ReturnValue);
}
public ReturnValue IsSessionIdValid(string Instance, string SessionId)
{
const string FUNCTION_NAME = "IsSessionIdValid";
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
ReturnValue ReturnValue = new ReturnValue();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for SessionId - " + SessionId);
try
{
if (ObjSessionValidation.IsSessionIdValid(SessionId, true))//true not to update the session updated time
{
ReturnValue.ReturnCode = 1;
ReturnValue.ReturnMessage = "Session Valid";
}
else
{
ReturnValue.ReturnCode = 0;
ReturnValue.ReturnMessage = "Session InValid";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for SessionId- " + SessionId);
return(ReturnValue);
}
public SessionUpdateResponse UpdateSessionId(int UserId)
{
string SessionId = string.Empty;
SessionUpdateResponse SessionUpdateResponse = new SessionUpdateResponse();
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "UpdateSessionId", "Start For UserID -" + UserId);
try
{
DataAccessLayer.DataAccessLayer DBLayer = new DataAccessLayer.DataAccessLayer();
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "UpdateSessionId", "Generating SessionId for UserId: " + UserId);
string Sessionid = System.Guid.NewGuid().ToString();
SICTLogger.WriteVerbose(UserDetailsBusiness.CLASS_NAME, "UpdateSessionId", "Inserting Session Id into the Session Table for UserId- " + UserId);
SessionId = DBLayer.InsertValuesToSessionTable(Sessionid, UserId);
if (!string.IsNullOrEmpty(SessionId))
{
SessionUpdateResponse.ReturnCode = 1;
SessionUpdateResponse.ReturnMessage = "Updationg SessionId Successful";
SessionUpdateResponse.SessionId = SessionId;
}
else
{
SessionUpdateResponse.ReturnCode = -1;
SessionUpdateResponse.ReturnMessage = "Updationg SessionId Failed in DB";
}
}
catch (System.Exception Ex)
{
SessionUpdateResponse.ReturnCode = -1;
SessionUpdateResponse.ReturnMessage = "Error in API";
SICTLogger.WriteException(UserDetailsBusiness.CLASS_NAME, "UpdateSessionId", Ex);
}
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "UpdateSessionId", "End For UserId " + UserId);
return(SessionUpdateResponse);
}
private void SetExcelCellStyle(ref Worksheet DataSheet, int Row, int Col, int FontSize, System.Drawing.Color Color, bool IsBackGroundColor = false, bool IsBold = false, int CellDataTypeNo = 0, bool IsTextWrap = false)
{
try
{
Cell cell = DataSheet.Cells[Row, Col];
Style style = cell.GetStyle();
style.Font.Name = "Calibri";
style.Font.IsBold = IsBold;
style.Font.Size = FontSize;
if (IsBackGroundColor)
{
style.Pattern = BackgroundType.Solid;
style.ForegroundColor = Color;
}
style.Number = CellDataTypeNo;
if (IsTextWrap)
{
style.IsTextWrapped = true;
}
cell.SetStyle(style);
if (cell.IsMerged)
{
cell.GetMergedRange().SetOutlineBorder(BorderType.TopBorder, CellBorderType.Thin, System.Drawing.Color.Black);
cell.GetMergedRange().SetOutlineBorder(BorderType.BottomBorder, CellBorderType.Thin, System.Drawing.Color.Black);
cell.GetMergedRange().SetOutlineBorder(BorderType.LeftBorder, CellBorderType.Thin, System.Drawing.Color.Black);
cell.GetMergedRange().SetOutlineBorder(BorderType.RightBorder, CellBorderType.Thin, System.Drawing.Color.Black);
}
}
catch (System.Exception Ex)
{
SICTLogger.WriteException(DownloadBusiness.CLASS_NAME, "SetExcelCellAttributes", Ex);
}
}
public ReturnValue UpdateInterviewer(string Instance, string SessionId, string Version, InterviewerDetail InterviewerDetail)
{
const string FUNCTION_NAME = "UpdateInterviewer";
ReturnValue ReturnValue = new ReturnValue();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start");
try
{
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
ManagementBusiness ObjManagementBusiness = new FactoryBusiness().GetManagementBusiness(Version);
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ReturnValue = ObjManagementBusiness.UpdateInterviewer(InterviewerDetail);
}
else
{
ReturnValue.ReturnCode = 0;
ReturnValue.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception ex)
{
ReturnValue.ReturnCode = -1;
ReturnValue.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End");
return(ReturnValue);
}
public string DBConnection(string Instance)
{
const string FUNCTION_NAME = "DBConnection";
string DBCon = string.Empty;
try
{
if (Instance == BusinessConstants.Instance.US.ToString())
{
DBCon = ConfigurationManager.ConnectionStrings[USIDBCONNECTION].ToString();
}
else if (Instance == BusinessConstants.Instance.AIR.ToString())
{
DBCon = ConfigurationManager.ConnectionStrings[AIRDBCONNECTION].ToString();
}
else if (Instance == BusinessConstants.Instance.EUR.ToString())
{
DBCon = ConfigurationManager.ConnectionStrings[EURDBCONNECTION].ToString();
}
else if (Instance == BusinessConstants.Instance.USD.ToString())
{
DBCon = ConfigurationManager.ConnectionStrings[USDDBCONNECTION].ToString();
}
}
catch (Exception ex)
{
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, ex);
}
return(DBCon);
}
///// <summary>
///// This Function is used to compress the cache files and update Dashboard Charts Cache Files
///// </summary>
//private void CompressLogFileandUpdateCacheFile()
//{
// const string FUNCTION_NAME = "CompressFile";
// SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start ");
// try
// {
// NameValueCollection Settings = System.Configuration.ConfigurationManager.GetSection("customAppSettingsGroup/Logs") as NameValueCollection;
// String[] AllFiles = Settings.AllKeys;
// foreach (String FileKey in AllFiles)
// {
// string StrValue = Settings.Get(FileKey);
// string[] StrArray = StrValue.Split(',');
// String SourceFileName = StrArray[0];//settings.Get(FILENAME);
// String SourceDir = StrArray[1];//settings.Get(SOURCEDIRECTORY);
// String DestDir = StrArray[2];// settings.Get(DESTINATIONDIRECTORY);
// string TgtFileName = StrArray[3];
// string TargetName = string.Concat(Path.GetFileNameWithoutExtension(TgtFileName),
// DateTime.Now.ToString("dd-MM-yyyy HH mm"), Path.GetExtension(TgtFileName));
// TargetName = string.Concat(DestDir, TargetName);
// // Use 7-zip, specify a=archive and -tgzip=gzip
// foreach (string f in Directory.GetFiles(SourceDir, SourceFileName, SearchOption.AllDirectories))
// {
// string SourceName = f;
// ProcessStartInfo Prc7ZipInfo = new ProcessStartInfo();
// Prc7ZipInfo.FileName = Convert.ToString(System.Configuration.ConfigurationManager.AppSettings[ZIPFILE]);
// Prc7ZipInfo.Arguments = " a -tzip \"" + TargetName + "\" \"" + SourceName + "\" ";
// Prc7ZipInfo.WindowStyle = ProcessWindowStyle.Hidden;
// Process Prc7Zip = Process.Start(Prc7ZipInfo);
// Prc7Zip.WaitForExit();
// }
// foreach (string f in Directory.GetFiles(SourceDir, SourceFileName, SearchOption.AllDirectories))
// {
// if (!IsFileLocked(f))
// File.Delete(f);
// }
// }
// //for updating cache files
// CreateCacheFileforTargetVsCompletesCharts(BusinessConstants.Instance.US.ToString());
// CreateCacheFileforTargetVsCompletesCharts(BusinessConstants.Instance.AIR.ToString());
// CreateCacheFileforTargetVsCompletesCharts(BusinessConstants.Instance.EUR.ToString());
// CreateCacheFileforTargetVsCompletesCharts(BusinessConstants.Instance.USD.ToString());
// }
// catch (Exception Ex)
// {
// SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
// }
// SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End ");
//}
/// <summary>
///Function to check if file is locked or is in use
/// </summary>
/// <param name="File">File name to be cheked</param>
/// <returns>returns if file is locked or not.</returns>
private bool IsFileLocked(String File)
{
const string FUNCTION_NAME = "IsFileLocked";
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start ");
FileStream Stream = null;
FileInfo Fileinfo = new FileInfo(File);
try
{
Stream = Fileinfo.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException)
{
//the file is unavailable because it is:
//still being written to
//or being processed by another thread
//or does not exist (has already been processed)
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "File is in use");
return(true);
}
finally
{
if (Stream != null)
{
Stream.Close();
}
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End ");
return(false);
}
/// <summary>
/// This Function is used to write the Missing Targets Vs Missing Business Class Data Passed to corresponding FilePath
/// </summary>
/// <param name="LoginId"></param>
/// <param name="MissingTargetsVsBusinessClass"></param>
private void WriteMissingTargetsVsBusinessClassChartCacheFile(string Instance, string LoginId, List <MissingTargetsVsBusinessClass> MissingTargetsVsBusinessClass)
{
const string FUNCTION_NAME = "WriteMissingTargetsVsBusinessClassChartCacheFile";
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for LoginId -" + LoginId);
try
{
string FilePath = string.Empty;
string FolderPath = string.Empty;
string MissingTargetsandBusinessClassData = string.Empty;
GetMissingTargetsVsBusinessClassChartsFilePath(Instance, LoginId, ref FilePath, ref FolderPath);
Boolean IsFolderExists = System.IO.Directory.Exists(FolderPath);
if (!IsFolderExists)
{
System.IO.Directory.CreateDirectory(FolderPath);
}
SICTLogger.WriteVerbose(CLASS_NAME, FUNCTION_NAME, "MissingTargetsVsBusinessClass Charts cache file for AirportLoginId- " + LoginId);
using (var MemoryStream = new MemoryStream())
{
var Serlizer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(List <MissingTargetsVsBusinessClass>));
Serlizer.WriteObject(MemoryStream, MissingTargetsVsBusinessClass);
MissingTargetsandBusinessClassData = System.Text.Encoding.UTF8.GetString(MemoryStream.GetBuffer(), 0, Convert.ToInt32(MemoryStream.Length));
WriteToFile(MissingTargetsandBusinessClassData, FilePath);
}
}
catch (Exception Ex)
{
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for LoginId -" + LoginId);
}
public void SendMail(string MailTo, string MailBody, string Title)
{
SICTLogger.WriteInfo(SMTPUtil.CLASS_NAME, "SendMail", "Started sending mail");
try
{
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(this.FromAddress);
if (this.IsRedirectMails || string.IsNullOrEmpty(this.FromAddress))
{
mailMessage.To.Add(new MailAddress(this.RedirectAddress));
}
else
{
mailMessage.To.Add(new MailAddress(MailTo));
}
mailMessage.Subject = Title;
mailMessage.Body = MailBody;
mailMessage.IsBodyHtml = true;
SmtpClient sMTPClient = this.GetSMTPClient();
sMTPClient.Send(mailMessage);
}
catch (Exception ex)
{
SICTLogger.WriteException(SMTPUtil.CLASS_NAME, "SendMail", ex);
}
SICTLogger.WriteInfo(SMTPUtil.CLASS_NAME, "SendMail", "Completed sending mail");
}
public FlightReportResponse GetFlightReport(string Instance, string Version, string SessionId, string AirportId, string OriginId, string DestinationId, string AirlineId, string FormType, string InterviewerId, string Route, string Direction, string FlightType, string AircraftType, string StartDate, string EndDate, string ResponseDate)
{
UserDetailsBusiness userDetailsBusiness = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
FlightReportResponse flightReportResponse = new FlightReportResponse();
SICTLogger.WriteInfo(ReportingServices.CLASS_NAME, "GetFlightReport", "Start ");
try
{
if (userDetailsBusiness.IsSessionIdValid(SessionId, false))
{
ReportingBusiness reportingBusiness = new FactoryBusiness().GetReportingBusiness(Version);
flightReportResponse = reportingBusiness.GetFlightReport(Instance, SessionId, AirportId, OriginId, DestinationId, AirlineId, FormType, Route, Direction, FlightType, AircraftType, InterviewerId, StartDate, EndDate, ResponseDate);
}
else
{
flightReportResponse.ReturnCode = 0;
flightReportResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(ReportingServices.CLASS_NAME, "GetFlightReport", "Invalid session ");
}
}
catch (Exception ex)
{
flightReportResponse.ReturnCode = -1;
flightReportResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(ReportingServices.CLASS_NAME, "GetFlightReport", ex);
}
SICTLogger.WriteInfo(ReportingServices.CLASS_NAME, "GetFlightReport", "End ");
return(flightReportResponse);
}
public FlightDeleteResponse DeleteFlightCombination(string Instance, string SessionId, string Version, string FlightCombinationId)
{
const string FUNCTION_NAME = "DeleteFlightCombination";
FlightDeleteResponse ReturnValue = new FlightDeleteResponse();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start");
try
{
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
ManagementBusiness ObjManagementBusiness = new FactoryBusiness().GetManagementBusiness(Version);
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ReturnValue = ObjManagementBusiness.DeleteFlightCombination(Instance, Convert.ToInt32(FlightCombinationId));
}
else
{
ReturnValue.ReturnCode = 0;
ReturnValue.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception ex)
{
ReturnValue.ReturnCode = -1;
ReturnValue.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End");
return(ReturnValue);
}
public ConfirmitCountsResponse GetConfirmitCounts(string Instance, string Version, string SessionId)
{
const string FUNCTION_NAME = "GetConfirmitCardDetails";
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
ConfirmitCountsResponse ConfirmitCountsResponse = new ConfirmitCountsResponse();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for SessionId - " + SessionId);
try
{
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ManagementBusiness ObjManagementBusiness = new FactoryBusiness().GetManagementBusiness(Version);
ConfirmitCountsResponse = ObjManagementBusiness.GetConfirmitCounts();
}
else
{
ConfirmitCountsResponse.ReturnCode = 0;
ConfirmitCountsResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
ConfirmitCountsResponse.ReturnCode = -1;
ConfirmitCountsResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for SessionId- " + SessionId);
return(ConfirmitCountsResponse);
}
public ResponseUserDetail GetAllUsers(string Instance, string Version, string SessionId)
{
const string FUNCTION_NAME = "GetAllUsers";
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start");
ResponseUserDetail ResponseUserDetail = new ResponseUserDetail();
try
{
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
UserDetailsBusiness ObjUserDetailsBusiness = new FactoryBusiness().GetUserDetailsBusiness(Version);
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ResponseUserDetail = ObjUserDetailsBusiness.GetAllUser();
}
else
{
ResponseUserDetail.ReturnCode = 0;
ResponseUserDetail.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
ResponseUserDetail.ReturnCode = -1;
ResponseUserDetail.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End ");
return(ResponseUserDetail);
}
public DownloadResponse FormExcelExport(string Instance, string SessionId, DepartureFormFilterDetails DepartureFormFilterDetails)
{
DownloadResponse DownloadResponse = new DownloadResponse();
BusinessUtil ObjBusinessUtil = new BusinessUtil();
SICTLogger.WriteInfo(DownloadBusiness.CLASS_NAME, "FormExcelExport", "Start ");
try
{
string FilePath = string.Empty;
string FileLink = string.Empty;
string FileName = string.Empty;
ObjBusinessUtil.GetFormsExcelExportFilePath(Instance, ref FilePath, ref FileLink, ref FileName);
DownloadResponse.ReturnCode = 1;
DownloadResponse.ReturnMessage = "Downloaded Started";
DownloadResponse.FileLink = FileLink;
DownloadResponse.FileName = FileName;
Task.Factory.StartNew(delegate
{
this.DownloadDataInBackground(SessionId, DepartureFormFilterDetails, FilePath);
});
}
catch (System.Exception Ex)
{
DownloadResponse.ReturnCode = -1;
DownloadResponse.ReturnMessage = "Error in Function ";
SICTLogger.WriteException(DownloadBusiness.CLASS_NAME, "FormExcelExport", Ex);
}
SICTLogger.WriteInfo(DownloadBusiness.CLASS_NAME, "FormExcelExport", "FormExcelExportEnd");
return(DownloadResponse);
}
public ReturnValue UploadFile(string Instance, string Version, string SessionId, Stream FileStream)
{
const string FUNCTION_NAME = "UploadFile";
ReturnValue Returnvalue = new ReturnValue();
string Error = string.Empty;
string UserId = string.Empty;
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start of UploadSPSSFile");
try
{
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
UploadBusiness ObjUploadBusiness = new FactoryBusiness().GetUploadBusiness(Version);
Returnvalue = ObjUploadBusiness.UploadFile(FileStream, Instance);
}
else
{
Returnvalue.ReturnCode = 0;
Returnvalue.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for UploadSPSSFile");
return(Returnvalue);
}
private byte[] ToByteArray(System.IO.Stream Stream)
{
SICTLogger.WriteInfo(MultiPartParser.CLASS_NAME, "Parse ", "Inside Multiparser Class Parse method, Converting to byte array");
byte[] result;
try
{
byte[] Buffer = new byte[2097152];
using (System.IO.MemoryStream Ms = new System.IO.MemoryStream())
{
while (true)
{
int read = Stream.Read(Buffer, 0, Buffer.Length);
if (read <= 0)
{
break;
}
Ms.Write(Buffer, 0, read);
}
result = Ms.ToArray();
}
}
catch (System.Exception Ex)
{
SICTLogger.WriteException(MultiPartParser.CLASS_NAME, "Parse ", Ex);
result = null;
}
return(result);
}
private bool ValidateFile(string FilePath)
{
SICTLogger.WriteInfo(UploadBusiness.CLASS_NAME, "ValidateFile", "Start");
bool IsValid = false;
try
{
string Type = System.IO.Path.GetExtension(FilePath);
if (Type.Equals(BusinessConstants.EXTENSION_CSV, System.StringComparison.InvariantCultureIgnoreCase))
{
System.IO.StreamReader File = new System.IO.StreamReader(FilePath);
string Line = File.ReadLine();
if (!string.IsNullOrEmpty(Line))
{
string[] Parameter = Line.Split(new char[]
{
','
});
int Length = Parameter.Length;
if (Parameter.Length >= 4)
{
IsValid = true;
SICTLogger.WriteVerbose(UploadBusiness.CLASS_NAME, "ValidateFile", "Valid CSV File");
}
}
}
}
catch (System.Exception Ex)
{
SICTLogger.WriteException(UploadBusiness.CLASS_NAME, "ValidateFile", Ex);
}
SICTLogger.WriteInfo(UploadBusiness.CLASS_NAME, "ValidateFile", "End");
return(IsValid);
}
private MultiPartParser ParseFile(System.IO.Stream Stream)
{
SICTLogger.WriteInfo(UploadBusiness.CLASS_NAME, "ParseFile ", "Start");
MultiPartParser Parser = null;
try
{
Parser = new MultiPartParser(Stream);
if (!Parser.Success)
{
SICTLogger.WriteError(UploadBusiness.CLASS_NAME, "ParseFile ", "Unable to parse the file");
Parser = null;
}
else
{
SICTLogger.WriteVerbose(UploadBusiness.CLASS_NAME, "ParseFile ", "Successfully parsed file - Filename is - " + Parser.Filename);
}
}
catch (System.Exception Ex)
{
SICTLogger.WriteException(UploadBusiness.CLASS_NAME, "ParseFile ", Ex);
}
SICTLogger.WriteInfo(UploadBusiness.CLASS_NAME, "ParseFile ", "End");
return(Parser);
}
public void SendMailWithAttachment(string MailTo, string MailBody, string Title, string[] FilePath)
{
SICTLogger.WriteInfo(SMTPUtil.CLASS_NAME, "SendMailWithAttachment", "Started sending mail");
try
{
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(this.FromAddress);
if (this.IsRedirectMails || string.IsNullOrEmpty(this.FromAddress))
{
mailMessage.To.Add(new MailAddress(this.RedirectAddress));
}
else
{
mailMessage.To.Add(new MailAddress(MailTo));
}
mailMessage.Subject = Title;
for (int i = 0; i < FilePath.Length; i++)
{
string path = FilePath[i];
mailMessage.Attachments.Add(new Attachment(Path.GetFullPath(path)));
}
mailMessage.Body = MailBody;
mailMessage.IsBodyHtml = true;
SmtpClient sMTPClient = this.GetSMTPClient();
sMTPClient.Send(mailMessage);
}
catch (Exception ex)
{
SICTLogger.WriteException(SMTPUtil.CLASS_NAME, "SendMailWithAttachment", ex);
}
}
public InterviewerDetailResponse GetInterviewersByRange(string Instance, string Version, string SessionId, string StartIndex, string Offset, string AirportId, string InterviewerName)
{
const string FUNCTION_NAME = "GetInterviewersByRange";
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
InterviewerDetailResponse InterviewerDetailResponse = new InterviewerDetailResponse();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for SessionId - " + SessionId);
try
{
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ManagementBusiness ObjManagementBusiness = new FactoryBusiness().GetManagementBusiness(Version);
InterviewerDetailResponse = ObjManagementBusiness.GetInterviewersbyRange(Convert.ToInt32(StartIndex), Convert.ToInt32(Offset), AirportId, InterviewerName);
}
else
{
InterviewerDetailResponse.ReturnCode = 0;
InterviewerDetailResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
InterviewerDetailResponse.ReturnCode = -1;
InterviewerDetailResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for SessionId- " + SessionId);
return(InterviewerDetailResponse);
}
public DownloadStatusResponse CheckDownloadStatus(string FileName)
{
DownloadStatusResponse DownloadStatusResponse = new DownloadStatusResponse();
BusinessUtil ObjBusinessUtil = new BusinessUtil();
SICTLogger.WriteInfo(DownloadBusiness.CLASS_NAME, "CheckDownloadStatus", "Start ");
try
{
string FilePath = string.Empty;
FilePath = ObjBusinessUtil.GetDownloadFilePathByName(FileName);
if (System.IO.File.Exists(FilePath))
{
DownloadStatusResponse.IsDownloadComplete = true;
DownloadStatusResponse.ReturnCode = 1;
DownloadStatusResponse.ReturnMessage = "Download Completed";
}
else
{
DownloadStatusResponse.IsDownloadComplete = false;
DownloadStatusResponse.ReturnCode = 5;
DownloadStatusResponse.ReturnMessage = "Download still in progress Completed";
}
}
catch (System.Exception Ex)
{
DownloadStatusResponse.ReturnCode = 1;
DownloadStatusResponse.ReturnMessage = "Error in Function ";
SICTLogger.WriteException(DownloadBusiness.CLASS_NAME, "CheckDownloadStatus", Ex);
}
SICTLogger.WriteInfo(DownloadBusiness.CLASS_NAME, "CheckDownloadStatus", "CheckDownloadStatusEnd");
return(DownloadStatusResponse);
}
public TargetDetailResponse GetTargetsByRange(string Instance, string Version, string SessionId, string StartIndex, string Offset, string FormType, string OriginId, string AirlineId, string Route, string Direction, string FlightType, string AircraftType, string Search, string Sort, string IsAsc)
{
const string FUNCTION_NAME = "GetInterviewersByRange";
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
TargetDetailResponse TargetDetailResponse = new TargetDetailResponse();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for SessionId - " + SessionId);
try
{
//int a = (BusinessConstants.Instance)Instance.;
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ManagementBusiness ObjManagementBusiness = new FactoryBusiness().GetManagementBusiness(Version);
TargetDetailResponse = ObjManagementBusiness.GetTargetsbyRange(Instance, Convert.ToInt32(StartIndex), Convert.ToInt32(Offset), FormType, OriginId, AirlineId, Route, Direction, FlightType, AircraftType, Search, Sort, IsAsc);
}
else
{
TargetDetailResponse.ReturnCode = 0;
TargetDetailResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
TargetDetailResponse.ReturnCode = -1;
TargetDetailResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for SessionId- " + SessionId);
return(TargetDetailResponse);
}
/// <summary>
/// This Function is used to write the TargetsVsCompletes Data Passed to corresponding FilePath
/// </summary>
/// <param name="LoginId"></param>
/// <param name="TargetsandCompletes"></param>
private void WriteTargetVsCompletesChartsCacheFile(string LoginId, List <TargetsVsCompletes> TargetsandCompletes)
{
const string FUNCTION_NAME = "WriteTargetVsCompletesChartsCacheFile";
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for LoginId -" + LoginId);
try
{
DepartureFormBusiness ObjDepartureFormBusiness = new DepartureFormBusiness();
BusinessUtil ObjBusinessUtil = new BusinessUtil();
string FilePath = string.Empty;
string FolderPath = string.Empty;
string TargetsandCompletesData = string.Empty;
ObjBusinessUtil.GetTargetVsCompletesChartsFilePath(LoginId, ref FilePath, ref FolderPath);
Boolean IsFolderExists = System.IO.Directory.Exists(FolderPath);
if (!IsFolderExists)
{
System.IO.Directory.CreateDirectory(FolderPath);
}
SICTLogger.WriteVerbose(CLASS_NAME, FUNCTION_NAME, "TargetVsCompletes Charts cache file for AirportLoginId- " + LoginId);
using (var MemoryStream = new MemoryStream())
{
var Serlizer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(List <TargetsVsCompletes>));
Serlizer.WriteObject(MemoryStream, TargetsandCompletes);
TargetsandCompletesData = System.Text.Encoding.UTF8.GetString(MemoryStream.GetBuffer(), 0, Convert.ToInt32(MemoryStream.Length));
ObjDepartureFormBusiness.WriteToFile(TargetsandCompletesData, FilePath);
}
}
catch (Exception Ex)
{
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for LoginId -" + LoginId);
}
public FlightCombinationResponse GetFlightCombinationsByRange(string Instance, string Version, string SessionId, string StartIndex, string Offset, string FormType, string OriginId, string DestinationId, string AirlineId, string Route, string Direction, string FlightType, string SearchVal, string SortVal, string SortOrder)
{
const string FUNCTION_NAME = "GetFlightCombinationsByRange";
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
FlightCombinationResponse FlightCombinationResponse = new FlightCombinationResponse();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start for SessionId - " + SessionId);
try
{
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
ManagementBusiness ObjManagementBusiness = new FactoryBusiness().GetManagementBusiness(Version);
FlightCombinationResponse = ObjManagementBusiness.GetFlightCombinationsByRange(Instance, Convert.ToInt32(StartIndex), Convert.ToInt32(Offset), FormType, OriginId, DestinationId, AirlineId, Route, Direction, FlightType, SearchVal, SortVal, string.IsNullOrEmpty(SortOrder)?false:Convert.ToBoolean(SortOrder));
}
else
{
FlightCombinationResponse.ReturnCode = 0;
FlightCombinationResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception Ex)
{
FlightCombinationResponse.ReturnCode = 0;
FlightCombinationResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, Ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End for SessionId- " + SessionId);
return(FlightCombinationResponse);
}
public AircraftQuotaReportResponse GetAircraftQuotaReport(string Instance, string Version, string SessionId, string AirportId, string StartDate, string EndDate, string IsBusinessQuota)
{
UserDetailsBusiness userDetailsBusiness = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
AircraftQuotaReportResponse aircraftQuotaReportResponse = new AircraftQuotaReportResponse();
SICTLogger.WriteInfo(ReportingServices.CLASS_NAME, "GetAircraftQuotaReport", "Start ");
try
{
if (userDetailsBusiness.IsSessionIdValid(SessionId, false))
{
ReportingBusiness reportingBusiness = new FactoryBusiness().GetReportingBusiness(Version);
aircraftQuotaReportResponse = reportingBusiness.GetAircraftQuotaReport(Instance, SessionId, AirportId, StartDate, EndDate, Convert.ToBoolean(IsBusinessQuota));
}
else
{
aircraftQuotaReportResponse.ReturnCode = 0;
aircraftQuotaReportResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(ReportingServices.CLASS_NAME, "GetAircraftQuotaReport", "Invalid session ");
}
}
catch (Exception ex)
{
aircraftQuotaReportResponse.ReturnCode = -1;
aircraftQuotaReportResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(ReportingServices.CLASS_NAME, "GetAircraftQuotaReport", ex);
}
SICTLogger.WriteInfo(ReportingServices.CLASS_NAME, "GetAircraftQuotaReport", "End ");
return(aircraftQuotaReportResponse);
}
public DownloadStatusResponse CheckDownloadStatus(string Instance, string Version, string SessionId, string FilePath)
{
const string FUNCTION_NAME = "CheckDownloadStatus";
DownloadStatusResponse DownloadStatusResponse = new DownloadStatusResponse();
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "Start");
try
{
UserDetailsBusiness ObjSessionValidation = new FactoryBusiness().GetUserDetailsBusiness(BusinessConstants.VERSION_BASE);
if (ObjSessionValidation.IsSessionIdValid(SessionId))
{
DownloadBusiness ObjDownloadBusiness = new FactoryBusiness().GetDownloadBusiness(Version);
DownloadStatusResponse = ObjDownloadBusiness.CheckDownloadStatus(FilePath);
}
else
{
DownloadStatusResponse.ReturnCode = 0;
DownloadStatusResponse.ReturnMessage = "Invalid session";
SICTLogger.WriteWarning(CLASS_NAME, FUNCTION_NAME, "Invalid session ");
}
}
catch (Exception ex)
{
DownloadStatusResponse.ReturnCode = -1;
DownloadStatusResponse.ReturnMessage = "Error in API Execution";
SICTLogger.WriteException(CLASS_NAME, FUNCTION_NAME, ex);
}
SICTLogger.WriteInfo(CLASS_NAME, FUNCTION_NAME, "End");
return(DownloadStatusResponse);
}
public LoginInformation CompareHashAndAuthenticate(string HashString)
{
LoginInformation LoginInformation = new LoginInformation();
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "CompareHashAndAuthenticate ", "Start ");
try
{
string UName = string.Empty;
DataAccessLayer.DataAccessLayer DBLayer = new DataAccessLayer.DataAccessLayer();
DataTable DataTable = new DataTable();
DataTable DtUpload = new DataTable();
bool IsAuthenticatedUser = false;
DataTable = DBLayer.GetAllUserNameAndPassword();
DtUpload = DBLayer.GetLastUploadDate();
foreach (DataRow Dr in DataTable.Rows)
{
string UserName = Dr[BusinessConstants.USERNAME].ToString();
string Password = Dr[BusinessConstants.PASSWORD].ToString();
string UserNameAndPassword = string.Format("{0}&{1}", UserName, Password);
if (string.Compare(this.CreateMD5Hash(UserNameAndPassword), HashString, true) == 0)
{
UName = UserName;
LoginInformation = this.Authenticate(Dr);
IsAuthenticatedUser = true;
break;
}
}
if (!IsAuthenticatedUser)
{
LoginInformation.ReturnCode = 0;
LoginInformation.SessionId = null;
LoginInformation.ReturnMessage = "Invalid Username or Password";
}
if (DtUpload.Rows.Count > 0)
{
System.Collections.Generic.List <string> UploadDates = new System.Collections.Generic.List <string>();
string UploadDate = string.Empty;
if (!string.IsNullOrEmpty(DtUpload.Rows[0][BusinessConstants.LASTUPLOADDATE].ToString()))
{
UploadDate = System.Convert.ToDateTime(DtUpload.Rows[0][BusinessConstants.LASTUPLOADDATE].ToString()).ToUniversalTime().ToString();
UploadDate = System.Convert.ToDateTime(UploadDate).ToString("MM/dd/yyyy/HH/mm");
UploadDate = UploadDate.Replace(".", "/");
UploadDate = UploadDate.Replace(":", "/");
LoginInformation.LastUploadDate = UploadDate;
}
}
LoginInformation.IsSpecialUser = this.CheckIsSpecialUserOrNot(UName);
LoginInformation.AirportId = System.Convert.ToInt32(DBLayer.GetAirportIdByUserName(UName));
}
catch (System.Exception Ex)
{
LoginInformation.ReturnCode = -1;
LoginInformation.ReturnMessage = "Error in Function Execution";
SICTLogger.WriteException(UserDetailsBusiness.CLASS_NAME, "CompareHashAndAuthenticate ", Ex);
}
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "CompareHashAndAuthenticate ", "End");
return(LoginInformation);
}
