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 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);
}
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 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 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);
}
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);
}
}
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);
}
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 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 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 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);
}
/// <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 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 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 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 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 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 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);
}
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 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 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 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 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);
}
public ReturnValue SendForgotPasswordMail(string Instance, string UserName, string UserMailId)
{
ReturnValue ReturnValue = new ReturnValue();
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "SendForgotPasswordMail", "Start");
try
{
string ToMailAdress = string.Empty;
ToMailAdress = ConfigurationManager.AppSettings[BusinessConstants.CONFIGURATION_SMTP_ADMINMAILID].ToString();
string InstanceName = string.Empty;
string logoImageURL = string.Empty;
if (Instance == BusinessConstants.Instance.US.ToString())
{
InstanceName = "US International";
}
else if (Instance == BusinessConstants.Instance.EUR.ToString())
{
InstanceName = "Europe";
}
else if (Instance == BusinessConstants.Instance.USD.ToString())
{
InstanceName = "US Domestic";
}
else if (Instance == BusinessConstants.Instance.AIR.ToString())
{
InstanceName = "Aircraft ";
}
string Title = string.Empty;
Title = "Forgot Password Request ";
SMTPUtil MailUtil = new SMTPUtil();
string MailBody = string.Empty;
string TemplatePath = BusinessConstants.CONFIGURATION_MAIL_FORGOTPASSWORDFORMATPATH;
using (System.IO.StreamReader InStream = new System.IO.StreamReader(ConfigurationManager.AppSettings[TemplatePath].ToString()))
{
MailBody = InStream.ReadToEnd();
}
MailBody = BusinessConstants.MAIL_FORGOT_PASSWORD_BODY;
MailBody = MailBody.Replace("@emailId", UserMailId);
MailBody = MailBody.Replace("@UserId", UserName);
MailBody = MailBody.Replace("@InstanceName", InstanceName);
MailBody = MailBody.Replace("@regardsAddress", ConfigurationManager.AppSettings[BusinessConstants.CONFIGURATION_SMTP_REGARDS].ToString());
MailBody = MailBody.Replace("@logoPath", ConfigurationManager.AppSettings[BusinessConstants.CONFIGURATION_SMTP_LOGOURL].ToString());
MailBody = MailBody.Replace("@appName", ConfigurationManager.AppSettings[BusinessConstants.CONFIGURATION_SMTP_APPNAME].ToString());
MailUtil.SendMail(ToMailAdress, MailBody, Title);
ReturnValue.ReturnCode = 1;
ReturnValue.ReturnMessage = "Mail Sent Successfully ";
}
catch (System.Exception ex)
{
SICTLogger.WriteException(UserDetailsBusiness.CLASS_NAME, "SendForgotPasswordMail", ex);
ReturnValue.ReturnCode = -1;
ReturnValue.ReturnMessage = "Mail Sending Failed";
}
SICTLogger.WriteInfo(UserDetailsBusiness.CLASS_NAME, "SendForgotPasswordMail", "End");
return(ReturnValue);
}
