/// <summary>
/// Saves the booking details report.
/// </summary>
/// <param name="booking">The booking.</param>
/// <param name="companyId">The company identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="bookingPath">The booking path.</param>
private Task SaveBookingDetailsReport(BookingInfo booking, int companyId, int userId, string bookingPath)
{
InventoryBL inventoryBL = new InventoryBL(DataContext);
string bookingDetailsFileName = string.Format("{0} {1} details", booking.BookingNumber, Utils.Ellipsize(booking.BookingName, 50));
BookingDetailsReportParameters parametersBookingDetails = new BookingDetailsReportParameters
{
BookingId = booking.BookingId,
BookingName = booking.BookingName,
CompanyId = companyId,
ContactPerson = null,
DisplayMode = "Admin",
ItemTypeId = 0,
RelatedTable = booking.RelatedTable,
SortExpression = string.Empty,
UserId = userId
};
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateBookingDetailsReport(parametersBookingDetails, ReportTypes.Excel,
out fileNameExtension, out encoding, out mimeType, true);
return(FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", bookingDetailsFileName, fileNameExtension), bookingPath));
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
Data.Project project = GetBL <ProjectBL>().GetProject(ProjectId);
string cultureName = Support.GetCultureName(project.Country.CountryCode);
TaskListReportParameters parameters = new TaskListReportParameters
{
CultureName = cultureName,
ProjectId = this.ProjectId,
SortExpression = taskList.TaskListSortExpression,
TaskListId = this.TaskListId,
UserId = this.UserID
};
var shoppingList = GetBL <ItemBriefBL>().GetTaskListByTaskListId(this.TaskListId);
string fileName = string.Format("{0}_TaskList", shoppingList.Name);
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateTaskListReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
if (!this.IsFromSharedCompany)
{
Data.Item item = GetBL <InventoryBL>().GetItem(this.ItemId);
if (item != null)
{
ItemBookingListReportParameters parameters = new ItemBookingListReportParameters
{
ItemId = this.ItemId,
SortExpression = gvBookingList.MasterTableView.SortExpressions.GetSortString(),
UserId = this.UserID
};
string fileName = item.Name + "_Bookings";
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateItemBookingListReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
}
}
/// <summary>
/// Generates the company inventory booking reports.
/// </summary>
/// <param name="companyId">The company identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="bookingPath">The booking path.</param>
private void GenerateCompanyInventoryBookingReports(int companyId, int userId, string bookingPath)
{
string fileName = "Booking List";
InventoryManageBookingListReportParameters parametersBookingList = new InventoryManageBookingListReportParameters
{
BookingStatus = null,
CompanyId = companyId,
CreatedByUserId = userId,
IsInventoryManagerMode = true,
SearchText = string.Empty,
ShowArchived = false,
SortExpression = string.Empty,
UserId = userId
};
string fileNameExtension;
string encoding;
string mimeType;
List <Task> asyncTaskList = new List <Task>();
byte[] reportBytes = UserWebReportHandler.GenerateInventoryManageBookingListReport(parametersBookingList, ReportTypes.Excel,
out fileNameExtension, out encoding, out mimeType);
asyncTaskList.Add(FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", fileName, fileNameExtension), bookingPath));
InventoryBL inventoryBL = new InventoryBL(DataContext);
var bookings = inventoryBL.GetBookingInfo(companyId, null, string.Empty, null, false);
foreach (BookingInfo booking in bookings)
{
asyncTaskList.Add(SaveBookingDetailsReport(booking, companyId, userId, bookingPath));
}
Task.WaitAll(asyncTaskList.ToArray());
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
int itemTypeId;
int.TryParse(ddItemTypes.SelectedValue, out itemTypeId);
string fileName = string.Empty;
Data.Company company = GetBL <CompanyBL>().GetCompany(ViewingCompanyId);
fileName = string.Format("{0}'s_Bookings", company.CompanyName);
BookingDetailsReportParameters parameters = new BookingDetailsReportParameters
{
BookingId = this.BookingId,
BookingName = GetBookingName(),
CompanyId = ViewingCompanyId,
ContactPerson = GetContactedPerson(),
DisplayMode = DisplayMode.ToString(),
ItemTypeId = itemTypeId,
RelatedTable = this.RelatedTableName,
SortExpression = gvBookingDetails.MasterTableView.SortExpressions.GetSortString(),
UserId = this.UserID,
ShowMyBookingsOnly = chkMyBookingsOnly.Checked
};
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateBookingDetailsReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType, true);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
var project = GetBL <ProjectBL>().GetProject(this.ProjectId);
if (project != null)
{
ItemisedPurchaseReportParameters parameters = new ItemisedPurchaseReportParameters
{
CultureName = this.CultureName,
ItemTypeId = projectItemTypes.SelectedItemTypeId,
ProjectId = this.ProjectId,
SortExpression = rgvItemisedPurchase.MasterTableView.SortExpressions.GetSortString(),
UserId = this.UserID
};
string fileName = string.Format("{0}_ItemisedPurchaseReport", project.ProjectName);
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateItemisedPurchaseReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
Data.Project project = GetBL <Logic.Business.Project.ProjectBL>().GetProject(ProjectId);
if (project != null)
{
string sortExpression = gvItems.MasterTableView.SortExpressions.GetSortString();
int itemTypeId = projectItemTypes.SelectedItemTypeId;
budgetList.ItemTypeID = itemTypeId;
BudgetSummaryReportParameters parameters = new BudgetSummaryReportParameters();
parameters.SortExpression = sortExpression;
parameters.ItemTypeId = projectItemTypes.SelectedItemTypeId;
parameters.UserId = this.UserID;
parameters.CultureName = CultureName;
parameters.ProjectId = this.ProjectId;
string fileName = string.Format("{0}_BudgetSummaryReport", project.ProjectName);
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateBudgetSummaryReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
string cultureName = string.Empty;
Data.Project project = GetBL <Logic.Business.Project.ProjectBL>().GetProject(ProjectId);
if (project != null)
{
cultureName = Support.GetCultureName(project.Country.CountryCode);
string fileNameExtension;
string encoding;
string mimeType;
string fileName = string.Format("{0}_Active_TaskList", project.ProjectName);
ActiveTaskListReportParameters parameters = new ActiveTaskListReportParameters
{
CultureName = cultureName,
ItemTypeId = projectItemTypes.SelectedItemTypeId,
ProjectId = ProjectId,
UserId = this.UserID
};
byte[] reportBytes = UserWebReportHandler.GenerateActiveTaskListReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
}
/// <summary>
/// Generates the item brief export file.
/// </summary>
/// <param name="projectId">The project identifier.</param>
/// <param name="baseFolder">The base folder.</param>
/// <param name="itemTypeDocumentMedia">The item type document media.</param>
private void GenerateItemBriefExportFile(int projectId, string baseFolder, ItemTypeDocumentMedia itemTypeDocumentMedia)
{
string fileName = string.Concat(itemTypeDocumentMedia.ItemTypeName, " - Item Brief List with all Specs");
string fileNameExtension = GlobalConstants.FileExtensions.ExcelFile;
string encoding;
string mimeType;
string attachmentPathItemBriefs = Path.Combine(baseFolder, itemTypeDocumentMedia.ItemTypeName);
byte[] reportBytes = UserWebReportHandler.GenerateItemBriefExport(projectId, itemTypeDocumentMedia.ItemTypeId, ReportTypes.Excel, out fileNameExtension, out encoding, out mimeType);
FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", fileName, fileNameExtension), attachmentPathItemBriefs).Wait();
}
/// <summary>
/// Generates the active task report.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="itemTypeName">Name of the item type.</param>
/// <param name="itemTypeId">The item type identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="folderPath">The folder path.</param>
private void GenerateActiveTaskReport(Project project, string itemTypeName, int itemTypeId, int userId, string folderPath)
{
string fileNameExtension;
string encoding;
string mimeType;
string fileName = string.Format("{0} - Tasks", itemTypeName);
ActiveTaskListReportParameters parameters = new ActiveTaskListReportParameters
{
CultureName = Utils.GetCultureName(project.Country.CountryCode),
ItemTypeId = itemTypeId,
ProjectId = project.ProjectId,
UserId = userId
};
byte[] reportBytes = UserWebReportHandler.GenerateActiveTaskListReport(parameters, ReportTypes.Excel,
out fileNameExtension, out encoding, out mimeType);
FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", fileName, fileNameExtension), folderPath).Wait();
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
Data.Project project = GetBL <Logic.Business.Project.ProjectBL>().GetProject(ProjectId);
if (project != null)
{
string fileTailName = string.Empty;
int itemTypeId = projectItemTypes.SelectedItemTypeId;
string sortExpression = "ItemBrief.Name ASC";
if (displaySettings.DisplayMode == ListViewDisplaySettings.ViewSettingValue.ListView)
{
sortExpression = gvItemList.MasterTableView.SortExpressions.GetSortString();
}
if (itemTypeId != 0)
{
fileTailName = string.Format("_{0}BriefList", Utils.GetItemTypeById(itemTypeId).Name);
}
else
{
fileTailName = "_ItemBriefList";
}
string fileName = project.ProjectName + fileTailName;
string fileNameExtension;
string encoding;
string mimeType;
ItemBriefListReportParameters parameters = new ItemBriefListReportParameters
{
ItemTypeId = itemTypeId,
ProjectId = ProjectId,
SortExpression = sortExpression,
UserId = this.UserID
};
byte[] reportBytes = UserWebReportHandler.GenerateItemBriefListReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType, true);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
}
/// <summary>
/// Generates the project budget summary report.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="folderPath">The folder path.</param>
private void GenerateProjectBudgetSummaryReport(Project project, int userId, string folderPath)
{
BudgetSummaryReportParameters parameters = new BudgetSummaryReportParameters();
parameters.SortExpression = string.Empty;
parameters.ItemTypeId = -1;
parameters.UserId = userId;
parameters.CultureName = Utils.GetCultureName(project.Country.CountryCode);
parameters.ProjectId = project.ProjectId;
string fileName = string.Format("{0} - Budget Summary Report", Utils.Ellipsize(project.ProjectName, 50));
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateBudgetSummaryReport(parameters, ReportTypes.Excel,
out fileNameExtension, out encoding, out mimeType);
FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", fileName, fileNameExtension), folderPath).Wait();
}
/// <summary>
/// Generates the itemised purchase report.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="itemTypeName">Name of the item type.</param>
/// <param name="itemTypeId">The item type identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="folderPath">The folder path.</param>
private void GenerateItemisedPurchaseReport(Project project, string itemTypeName, int itemTypeId, int userId, string folderPath)
{
ItemisedPurchaseReportParameters parameters = new ItemisedPurchaseReportParameters
{
CultureName = Utils.GetCultureName(project.Country.CountryCode),
ItemTypeId = itemTypeId,
ProjectId = project.ProjectId,
SortExpression = string.Empty,
UserId = userId
};
string fileName = string.Format("{0} - Itemised Purchase Report", itemTypeName);
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateItemisedPurchaseReport(parameters, ReportTypes.Excel,
out fileNameExtension, out encoding, out mimeType);
FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", fileName, fileNameExtension), folderPath).Wait();
}
/// <summary>
/// Exports the report.
/// </summary>
/// <param name="exportType">Type of the export.</param>
private void ExportReport(ReportTypes exportType)
{
string fileName = string.Empty;
InventoryManageBookingListReportParameters parameters = new InventoryManageBookingListReportParameters
{
BookingStatus = this.BookingStatus,
CompanyId = this.CompanyId,
CreatedByUserId = this.CreatedByUserId,
IsInventoryManagerMode = this.DisplayMode == ViewMode.InventoryManager,
SearchText = cboSearch.Text,
ShowArchived = this.ShowArchived,
SortExpression = gvBookings.MasterTableView.SortExpressions.GetSortString(),
UserId = this.UserID
};
if (this.DisplayMode == ViewMode.InventoryManager)
{
Data.Company company = GetBL <CompanyBL>().GetCompany(this.CompanyId.Value);
if (company != null)
{
fileName = string.Format("{0}'s_Bookings", company.CompanyName);
}
}
else if (this.DisplayMode == ViewMode.MyBookings)
{
Data.User user = GetBL <PersonalBL>().GetUser(this.CreatedByUserId.Value);
if (user != null)
{
fileName = string.Format("{0}'s_Bookings", user.FirstName);
}
}
string fileNameExtension;
string encoding;
string mimeType;
byte[] reportBytes = UserWebReportHandler.GenerateInventoryManageBookingListReport(parameters, exportType,
out fileNameExtension, out encoding, out mimeType);
Utils.ExportReport(reportBytes, mimeType, fileNameExtension, fileName);
}
/// <summary>
/// Creates the company export file.
/// </summary>
/// <param name="companyId">The company identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="fileSize">Size of the file.</param>
/// <returns>Is success.</returns>
private bool CreateCompanyExportFile(int companyId, int userId, out long fileSize)
{
CompanyBL companyBL = new CompanyBL(DataContext);
string baseFolder = companyBL.GetExportFileLocation(Common.Constants.GlobalConstants.RelatedTables.ExportFiles.Company, companyId);
if (baseFolder.Trim().Length > 0)
{
try
{
// Intialize Cancellation Token.
CancellationTokenSource cts = new CancellationTokenSource();
ParallelOptions po = new ParallelOptions();
po.CancellationToken = cts.Token;
string bookingPath = Path.Combine(baseFolder, "Bookings");
FileHandler.CreateFolder(bookingPath);
// Generate booking reports.(new Task/Thread.)
Task bookingReportTask = Task.Factory.StartNew(() =>
{
try
{
GenerateCompanyInventoryBookingReports(companyId, userId, bookingPath);
}
catch (Exception ex)
{
// Request cancel for all other pending tasks. And throw the exception.
cts.Cancel();
throw ex;
}
}, cts.Token);
// Generate item type reports and item brief attachements.(new Task/Thread.)
Task itemTypeTask = Task.Factory.StartNew(() =>
{
var groupedDocumentMedias = companyBL.GetItemTypeDocumentMediaByCompany(companyId);
// Check for the cancel request. (after starting the task).
cts.Token.ThrowIfCancellationRequested();
Parallel.ForEach <ItemTypeDocumentMedia>(groupedDocumentMedias, po, dm =>
{
try
{
// Create Item List with all Specs report
Task itemReportTask = Task.Factory.StartNew(() =>
{
try
{
string fileName = string.Concat(dm.ItemTypeName, " - Item List with all Specs");
string fileNameExtension = GlobalConstants.FileExtensions.ExcelFile;
string encoding;
string mimeType;
string attachmentPathCI = Path.Combine(baseFolder, dm.ItemTypeName);
byte[] reportBytes = UserWebReportHandler.GenerateInventoryExport(companyId, dm.ItemTypeId, ReportTypes.Excel, out fileNameExtension, out encoding, out mimeType);
FileHandler.SaveFileToDisk(reportBytes, string.Format("{0}.{1}", fileName, fileNameExtension), attachmentPathCI).Wait();
}
catch (Exception ex)
{
// Request cancel for all other pending tasks. And throw the exception.
cts.Cancel();
//throw ex;
}
}, cts.Token);
string attachmentPath = Path.Combine(baseFolder, dm.ItemTypeName, "Attachments");
FileHandler.CreateFolder(attachmentPath);
// Generate attachments.
// single threaded.
// Due to the fact that this is an heavy IO bound operation which is recomended to do async.
List <Task> asyncTaskList = new List <Task>();
foreach (DocumentMediaInfo documentMediaInfo in dm.DocumentMedias)
{
// Check for the cancel request. (after starting the task).
cts.Token.ThrowIfCancellationRequested();
string filePrefix = string.Format("{0} {1} - ", documentMediaInfo.EntityId, Utils.Ellipsize(documentMediaInfo.EntityName, 50));
asyncTaskList.Add(SaveDocumentMedia(filePrefix, documentMediaInfo.DocumentMediaId, attachmentPath));
}
// Wait for all async taks.
Task.WaitAll(asyncTaskList.ToArray());
// Wait for report task.
itemReportTask.Wait();
}
catch (Exception ex)
{
// Request cancel for all other pending tasks. And throw the exception.
cts.Cancel();
throw ex;
}
});
}, cts.Token);
Task[] tasks = new[] { bookingReportTask, itemTypeTask };
try
{
Task.WaitAll(tasks, cts.Token);
string zipPath = string.Concat(baseFolder, ".zip");
FileHandler.CreateZipFile(baseFolder, zipPath);
fileSize = FileHandler.GetFileSize(zipPath);
return(true);
}
catch (OperationCanceledException)
{
// One or more operations has been canceled. Wait for other running tasks to complete. (Any status => success or failed).
Task.Factory.ContinueWhenAll(tasks, _ =>
{
// Get exceptions from failed tasks.
Exception[] exceptions = tasks.Where(t => t.IsFaulted).Select(t => t.Exception).ToArray();
foreach (Exception e in exceptions)
{
// log failures.
AgentErrorLog.HandleException(e);
}
}).Wait();
}
}
catch (AggregateException ae)
{
foreach (Exception e in ae.Flatten().InnerExceptions)
{
// log failures.
AgentErrorLog.HandleException(e);
}
}
finally
{
FileHandler.DeleteFolder(baseFolder);
}
}
fileSize = 0;
return(false);
}
