public async Task <CreateReportResponse> Execute(CreateReportRequest request)
{
var validationErrors = _validationService.Validate(request);
if (validationErrors.Any())
{
return(new CreateReportResponse
{
Data = new Either <Dtos.ReportDto, IEnumerable <KeyValuePair <string, string> > >(validationErrors)
});
}
var report = new Entities.Report();
_reportRepository.AddEntity(report);
report.ReportTypeId = (int)request.Model.ReportTypeId;
report.AverageSpeed = request.Model.AverageSpeed;
report.InstructedSpeed = request.Model.InstructedSpeed;
await _reportRepository.SaveChangesAsync();
return(new CreateReportResponse
{
Data = new Either <Dtos.ReportDto, IEnumerable <KeyValuePair <string, string> > >(new Dtos.ReportDto
{
ReportId = report.ReportId,
AverageSpeed = report.AverageSpeed,
InstructedSpeed = report.InstructedSpeed,
ReportTypeId = report.ReportTypeId
})
});
}
public string generateReport(Entities.medicinesDispense med)
{
var report = new BuidReport();
var reportEntity = new Entities.Report();
var reportName = string.Empty;
var folderName = string.Empty;
//var serverPath = HttpContext.Current.Server.MapPath("../POS/");
var parameters = new ArrayList();
parameters.Add(med.FromDate);
parameters.Add(med.ToDate);
folderName = "PreEmploymentDetails";
reportName = "medicinesDispenseReport.rpt";
var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
reportEntity.DirectoryPath = serverPath + "ApplicationFiles/" + folderName + "/";
reportEntity.ReportPath = serverPath + "Reports/" + reportName;
reportEntity.Parameters = parameters;
reportEntity.FileStoragePath = reportEntity.DirectoryPath + Convert.ToString("MedicinesDispense") + ".pdf";
return(report.GenerateReport(reportEntity, CrystalDecisions.Shared.ExportFormatType.PortableDocFormat));
}
public string XrayIssueReportPrint(Entities.StockReport stock)
{
var report = new BuidReport();
var reportEntity = new Entities.Report();
var reportName = string.Empty;
var folderName = string.Empty;
//var serverPath = HttpContext.Current.Server.MapPath("../POS/");
var parameters = new ArrayList();
parameters.Add(stock.FromDate);
parameters.Add(stock.ToDate);
folderName = "StockReport";
reportName = "X-RayIssueReport.rpt";
var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
reportEntity.DirectoryPath = serverPath + "ApplicationFiles/" + folderName + "/";
reportEntity.ReportPath = serverPath + "Reports/" + reportName;
reportEntity.Parameters = parameters;
reportEntity.FileStoragePath = reportEntity.DirectoryPath + Convert.ToString("XrayIssueReport") + ".pdf";
return(report.GenerateReport(reportEntity, CrystalDecisions.Shared.ExportFormatType.PortableDocFormat));
}
public async Task <int> UpdateReportAsync(Entities.Report r)
{
using (var conn = _connProvider.GetConnection())
{
return(await conn.ExecuteAsync(@"update Reports set Status=@Status,ProcessUID=@ProcessUID,Result=@Result,ProcessTime=@ProcessTime
where ID=@ID", r));
}
}
public async Task <int> AddReportAsync(Entities.Report r)
{
using (var conn = _connProvider.GetConnection())
{
return(await conn.ExecuteAsync(@"insert into Reports (UID,Type,TargetID,Reason,Status,ReportTime)
values(@UID,@Type,@TargetID,@Reason,@Status,@ReportTime)", r));
}
}
public string GetReport(Entities.Report report)
{
var maxReport = Repository.GetAll <Entities.MaxReport>()
.Where(x => x.Report.Id == report.Id)
.FirstOrDefault();
if (maxReport == null)
{
return("Report not found. Please create a new one");
}
return($"Max: {maxReport.Max}\nMin: {maxReport.Min}\nAvg: {maxReport.Avg}");
}
public string generateReport(Entities.PreEmploymentDetails preEmploymentDetails)
{
var report = new BuidReport();
var reportEntity = new Entities.Report();
var reportName = string.Empty;
var folderName = string.Empty;
//var serverPath = HttpContext.Current.Server.MapPath("../POS/");
var fileName = "No Records";
try
{
var parameters = new ArrayList();
parameters.Add(preEmploymentDetails.PreEmploymentId);
folderName = "PreEmploymentDetails";
reportName = "PreEmploymentDetails.rpt";
if (preEmploymentDetails.PreEmploymentOrHealthCheckup.ToLower() == "h")
{
folderName = "HealthCheckupDetails";
reportName = "HealthCheckupDetails.rpt";
}
////LogWriter logWriter = new LogWriter(fileName);
////LogWriter //logWriter = new LogWriter("Inside Generate REport Method");
//LogWriter logWriter = new LogWriter(folderName + ", " + reportName + ", " + preEmploymentDetails.PreEmploymentId.ToString() + ", " + "," + preEmploymentDetails.PreEmploymentOrHealthCheckup);
var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
reportEntity.DirectoryPath = serverPath + "ApplicationFiles/" + folderName + "/";
reportEntity.ReportPath = serverPath + "Reports/" + reportName;
reportEntity.Parameters = parameters;
reportEntity.FileStoragePath = reportEntity.DirectoryPath + Convert.ToString(preEmploymentDetails.PreEmploymentCodeNo) + ".pdf";
//logWriter = new LogWriter(folderName + ", " + reportName + ", " + reportEntity.DirectoryPath + ", " + "," + reportEntity.FileStoragePath);
fileName = report.GenerateReport(reportEntity, CrystalDecisions.Shared.ExportFormatType.PortableDocFormat);
}
catch (Exception ex)
{
LogWriter logWriter = new LogWriter("Inside Generate REport Method");
logWriter = new LogWriter(ex.Message);
}
return(fileName);
}
public async Task <IHttpActionResult> AddReport(ReportViewModel Report)
{
Report ReportEntity = new Entities.Report();
ReportEntity.Details = Report.Details;
Guid reportID = await _reportDataService.AddReportAsync(ReportEntity, true);
IHttpActionResult response;
if (reportID != Guid.Empty)
{
response = ResponseMessage(Request.CreateResponse <Guid>(HttpStatusCode.OK, reportID));
}
else
{
response = BadRequest();
}
return(response);
}
public int Generate(string templateId)
{
var reportId = Repository.GetAll <Entities.Report>()
.Max(x => (int?)x.ReportId);
var report = new Entities.Report
{
TemplateId = templateId,
StartDate = DateTime.Now,
ReportStatus = Enums.ReportStatus.Queue,
ReportId = !reportId.HasValue ? 1 : reportId.Value + 1
};
Repository.Save(report);
_reportQueue.Enqueue(report);
_evt.Set();
return(report.ReportId);
}
private void insert()
{
DateTime e;
try
{
e = DateTime.ParseExact(time, "HH:mm:ss", CultureInfo.InvariantCulture);
}
catch { return; }
if (date == null)
{
return;
}
var d = new DateTime(date.Year, date.Month, date.Day, e.Hour, e.Minute, e.Second);
log.LogMessege(d.ToString(), true);
this.Selectplace = internet.getLocData(0);
if (location != null)
{
var report = new Entities.Report(Guid.NewGuid().ToString("N"), d, new string[2] {
location.Latitude.ToString(), location.Longitude.ToString()
}, "");
this.d.addReport(report);
}
else if (Selectplace != null)
{
var report = new Entities.Report(Guid.NewGuid().ToString("N"), d, new string[2] {
Selectplace["lat"], Selectplace["lon"]
}, "");
this.d.addReport(report);
}
else
{
log.LogMessege("no place...", true);
}
}
public string generateReport(Entities.Precautions pre)
{
var report = new BuidReport();
var reportEntity = new Entities.Report();
var reportName = string.Empty;
var folderName = string.Empty;
//var serverPath = HttpContext.Current.Server.MapPath("../POS/");
var parameters = new ArrayList();
parameters.Add(pre.DrugDispenseId);
reportName = "Precaution_Reports.rpt";
var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
reportEntity.DirectoryPath = serverPath + "ApplicationFiles/PatientNo/";
reportEntity.ReportPath = serverPath + "Reports/" + reportName;
reportEntity.Parameters = parameters;
reportEntity.FileStoragePath = reportEntity.DirectoryPath + "PatientNo_" + Convert.ToString(pre.DrugDispenseId) + ".pdf";
return(report.GenerateReport(reportEntity, CrystalDecisions.Shared.ExportFormatType.PortableDocFormat));
}
public void Generate(Entities.Report report)
{
var summary = Repository.GetAll <Product>()
.GroupBy(x => 1)
.Select(x => new
{
Max = x.Max(y => y.Price),
Min = x.Min(y => y.Price),
Avg = x.Average(y => y.Price)
})
.First();
var entity = new Entities.MaxReport
{
Max = summary.Max,
Min = summary.Min,
Avg = summary.Avg
};
Repository.Save(entity);
entity.Report = report;
Repository.Update(entity);
}
public async Task <IHttpActionResult> Login(HttpRequestMessage request, [FromBody] LoginViewModel model)
{
IHttpActionResult response = null;
try
{
CustomIdentityUser user = await UserManager.FindByNameAsync(model.UserName);
//if (user != null && user.DBUser.LockoutEndDateUtc != null)
if (user != null)
{
switch (user.DBUser.StatusID)
{
case (short)AccountStatus.Inactive:
ModelState.AddModelError("error", Resource.AccountInactive);
return(BadRequest(ModelState));
break;
case (short)AccountStatus.Locked:
ModelState.AddModelError("error", Resource.AccountLockout);
return(BadRequest(ModelState));
break;
case (short)AccountStatus.Disabled:
ModelState.AddModelError("error", Resource.AccountDisabled);
return(BadRequest(ModelState));
break;
}
}
//if (user != null && user.DBUser.StatusID == (short)AccountStatus.Locked)
//{
// ModelState.AddModelError("error", Resource.AccontLockout);
// return BadRequest(ModelState);
//}
var result = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, shouldLockout : true);
if (result == SignInStatus.Success)
{
user = await UserManager.FindByNameAsync(model.UserName);
user.DBUser.LastLoginDate = DateTime.Now;
await UserManager.UpdateAsync(user);
Report ReportEntity = new Entities.Report()
{
UserID = user.DBUser.ID,
OrganizationID = user.DBUser.Organization.OrganizationID,
ReportTypeID = (int)ReportType.Login,
Details = "LOGIN",
IsSuccess = true,
TicketID = null,
CreatedDateUtc = DateTime.UtcNow
};
//Guid reportID = await _reportDataService.AddReportAsync(ReportEntity, false);
//
}
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
else
{
response = Ok();
}
}
catch (Exception ex)
{
string message = UserHelper.ErrorHandler(ex);
response = BadRequest(message);
}
return(response);
}
public string GenerateReport(Entities.Report report, ExportFormatType exportFormat)
{
string filePath = null;
try
{
_tableLogOnInfo = new TableLogOnInfo();
_reportDocument = new ReportDocument();
connectionStringBuilder = new SqlConnectionStringBuilder(ConfigurationManager.ConnectionStrings["DBConnectionString"].ConnectionString);
_dbConnectionInfo = new ConnectionInfo();
_tableLogOnInfo = new TableLogOnInfo();
//Create a folder if not exists
if (Directory.Exists(report.DirectoryPath) == false)
{
Directory.CreateDirectory(report.DirectoryPath);
}
var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
//File.AppendAllText(serverPath + "/log.txt", report.ReportPath);
_reportDocument.Load(report.ReportPath);
//Reading the db connection file
string serverName = connectionStringBuilder.DataSource;
string databaseName = connectionStringBuilder.InitialCatalog;
string userId = connectionStringBuilder.UserID;
string password = connectionStringBuilder.Password;
_dbConnectionInfo.ServerName = serverName;
_dbConnectionInfo.DatabaseName = databaseName;
_dbConnectionInfo.UserID = userId;
_dbConnectionInfo.Password = password;
foreach (CrystalDecisions.CrystalReports.Engine.Table table in _reportDocument.Database.Tables)
{
_tableLogOnInfo = table.LogOnInfo;
_tableLogOnInfo.ConnectionInfo = _dbConnectionInfo;
table.ApplyLogOnInfo(_tableLogOnInfo);
}
if (report.Parameters != null)
{
if (report.Parameters.Count > 0)
{
for (int items = 0; items < report.Parameters.Count; items++)
{
_reportDocument.SetParameterValue(items, report.Parameters[items].ToString());
}
}
else if (report.Parameters.Count == 0)
{
_reportDocument.RecordSelectionFormula = report.RecordSelectionFormula;
}
}
else
{
_reportDocument.RecordSelectionFormula = report.RecordSelectionFormula;
}
//serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
//File.AppendAllText(serverPath + "/log.txt", "Report Parameters");
_diskFileDestinationOptions = new DiskFileDestinationOptions();
//_exportOptions = new ExportOptions();
_reportFormatOptions = new PdfRtfWordFormatOptions();
_exportOptions = _reportDocument.ExportOptions;
_diskFileDestinationOptions.DiskFileName = report.FileStoragePath;
_exportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
_exportOptions.ExportFormatType = exportFormat;
_exportOptions.ExportDestinationOptions = _diskFileDestinationOptions;
_exportOptions.ExportFormatOptions = _reportFormatOptions;
_reportDocument.Export();
//var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
//File.AppendAllText(serverPath + "/log.txt", "File Storeage path " + report.FileStoragePath);
filePath = report.FileStoragePath;
}
catch (Exception ex)
{
//var serverPath = HttpContext.Current.Server.MapPath("/HealthScreeningApp/");
//File.AppendAllText(serverPath + "/log.txt", ex.Message);
throw new Exception("Error as " + ex.Message);
//LogEntry.LogExceptions.WriteLog("ExportCrystalReportClassLibrary", ex.GetType().ToString(), ex.Message.ToString(), ex.Source.ToString(), "WEB");
}
finally
{
_reportDocument.Close();
}
return(filePath);
}
