public static ReportFormat LoadReportFormat(string id)
{
int formatId = int.Parse(id);
#if MOCKUP
#else
using (var sql = new Emdat.InVision.Sql.ReportingDataContext())
{
var formats =
from f in sql.GetFormat(formatId)
select new ReportFormat
{
Id = f.ReportFormatID.ToString(),
Name = f.Name,
Description = f.Description,
IsActive = f.IsActive,
Value = f.SSRSFormat,
FileExtension = f.Extension,
HttpContentType = f.HTTPContentType,
DeviceInfo = f.SSRSDeviceInfo
};
return(formats.FirstOrDefault());
}
#endif
}
public static void DeleteSubscription(Subscription subscription)
{
//TODO: invalidate cached objects that are related to the specified subscription
int subscriptionId = int.Parse(subscription.Id);
#if MOCKUP
//build the subscriptions path
string path = Path.Combine(System.Configuration.ConfigurationManager.AppSettings["AppDataPathForMockup"], "Subscriptions");
//find the file
string file =
(from f in Directory.GetFiles(path, string.Format("{0}.xml", subscription.Id), SearchOption.AllDirectories)
select f)
.FirstOrDefault();
if (file != null)
{
File.Delete(file);
}
#else
using (var sql = new Emdat.InVision.Sql.ReportingDataContext())
{
sql.DeleteSubscription(subscriptionId);
}
#endif
}
public static IEnumerable <Category> ListCategories(int userId, ReportingApplication application)
{
#if MOCKUP
XDocument doc = XDocument.Load(Path.Combine(System.Configuration.ConfigurationManager.AppSettings["AppDataPathForMockup"], "Reports.xml"));
XElement root = doc.Element("Reports");
var reportCategories =
from e in root.Elements("Report")
orderby !string.IsNullOrEmpty(e.Attribute("Category_UISortOrder").Value) ? (int)e.Attribute("Category_UISortOrder") : int.MaxValue
group e by(string) e.Attribute("Category") into categoryGroup
select new Category
{
Name = !string.IsNullOrEmpty(categoryGroup.Key) ? categoryGroup.Key : "Miscellaneous Reports"
};
return(reportCategories);
#else
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var reportCategories =
from r in sql.ListReports(userId)
orderby r.CategorySortOrder
group r by r.CategoryName into categoryGroup
select new Category
{
Name = !string.IsNullOrEmpty(categoryGroup.Key) ? categoryGroup.Key : "Miscellaneous Reports"
};
return(reportCategories.ToList());
}
#endif
}
/// <summary>
/// Loads the execution data.
/// </summary>
/// <param name="execution">The execution.</param>
/// <returns></returns>
public static byte[] LoadExecutionData(Execution execution)
{
if (execution == null)
{
throw new ArgumentNullException("execution");
}
if (!execution.Application.HasValue)
{
throw new InvalidOperationException("Application must be set");
}
if (string.IsNullOrEmpty(execution.Id))
{
throw new InvalidOperationException("Id must be set");
}
int executionId = int.Parse(execution.Id);
using (var data = new Emdat.InVision.Sql.ReportingDataContext(execution.Application.Value, "Emdat.InVision.ReportContent"))
{
var result = data.GetExecutionData(executionId).FirstOrDefault();
if (result == null || result.Data == null)
{
throw new KeyNotFoundException(string.Format("Could not find data for report: {0}", executionId));
}
return(result.Data);
}
}
public static void AddExecution(Subscription subscription, ReportingApplication application)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
sql.AddSubscriptionExecution(int.Parse(subscription.Id), int.Parse(subscription.ReportId), int.Parse(subscription.FormatId), subscription.GetParameterValuesXml());
}
}
public static IEnumerable <Category> ListReportsByCategory(int userId, ReportingApplication application)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var reportCategories =
from r in sql.ListReports(userId)
orderby r.CategorySortOrder
group r by r.CategoryName into categoryGroup
select new Category
{
Name = !string.IsNullOrEmpty(categoryGroup.Key) ? categoryGroup.Key : "Miscellaneous Reports",
Reports =
from r in categoryGroup
orderby
r.SortOrder.HasValue ? r.SortOrder.Value : int.MaxValue,
r.Name
select new Report
{
Id = r.ReportID.ToString(),
Name = r.Name,
Description = r.Description,
ReportingServicesPath = r.ReportPath,
Category = categoryGroup.Key,
ReportParametersUrl = r.ReportParametersURL,
ReportingEnvironmentId = (ReportingEnvironmentEnum)r.EnvironmentID,
ReportingEnvironmentName = r.EnvironmentName
}
};
return(reportCategories.ToList());
}
}
public static IEnumerable <ExecutionStatus> ListExecutionStatuses()
{
#if MOCKUP
return(new ExecutionStatus[]
{
new ExecutionStatus
{
Id = "1",
Name = "Pending",
Description = ""
},
new ExecutionStatus
{
Id = "2",
Name = "Queued",
Description = ""
},
new ExecutionStatus
{
Id = "3",
Name = "Running",
Description = ""
},
new ExecutionStatus
{
Id = "4",
Name = "Succeeded",
Description = ""
},
new ExecutionStatus
{
Id = "5",
Name = "Error",
Description = ""
}
});
#else
if (_statuses == null ||
_expireTime < DateTime.Now)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext())
{
var statuses =
from s in sql.ListExecutionStatuses()
select new ExecutionStatus
{
Id = (ExecutionStatusEnum)s.ReportExecutionStatusID,
Name = s.Name,
Description = s.Description
};
_statuses = statuses.ToList();
_expireTime = DateTime.Now.AddMinutes(5);
}
}
return(_statuses);
#endif
}
public static Execution LoadExecution(string id, int userId, ReportingApplication application)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
int executionId = int.Parse(id);
if (executionId < 1)
{
throw new ArgumentOutOfRangeException("id");
}
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var result =
(from e in sql.GetExecution(userId, executionId)
select new Execution
{
Application = application,
OwnerId = userId.ToString(),
Id = e.ReportExecutionID.ToString(),
Description = e.Name,
SubscriptionId = e.ReportSubscriptionID.ToString(),
ReportingEnvironmentId = (ReportingEnvironmentEnum)e.EnvironmentID,
ReportingEnvironmentName = e.EnvironmentName,
ReportId = e.ReportID.ToString(),
StatusId = (ExecutionStatusEnum)e.ReportExecutionStatusID,
FormatId = e.ReportFormatID.ToString(),
Parameters = ReportParametersHelper.GetParameterValuesFromXml(e.Parameters),
ActualCompletionTime = e.EndDate,
ActualStartTime = e.StartDate,
ExpirationDate = e.ExpirationDate,
ScheduledRunTime = e.ScheduledStartDate,
ModifiedDate = e.ModifiedDate,
ModifiedUser = e.ModifiedUser,
ErrorName = e.ErrorName,
ErrorDescription = e.ErrorDescription
})
.FirstOrDefault();
if (result == null)
{
throw new KeyNotFoundException(string.Format("The report execution could not be found for user {0}: {1}", userId, executionId));
}
return(result);
}
}
public static Report LoadReport(string reportId, int userId, int?clientId, ReportingApplication application, ReportingEnvironmentEnum environment)
{
#region input validation
if (string.IsNullOrEmpty(reportId))
{
throw new ArgumentNullException("reportId");
}
int reportIdValue = int.Parse(reportId);
#endregion
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
Report report =
(from r in sql.GetReport(reportIdValue, (int)environment)
select new Report
{
Id = r.ReportID.ToString(),
Name = r.Name,
Description = r.Description,
ReportingServicesPath = r.ReportPath,
Category = r.CategoryName,
ReportParametersUrl = r.ReportParametersURL,
Options = r.Options
})
.FirstOrDefault();
if (report == null)
{
throw new KeyNotFoundException(string.Format("The report could not be found: {0}", reportId));
}
else
{
if (ReportingApplication.InQuiry == application && clientId.HasValue)
{
var clientLabels = ClientLabels.LoadClientLabels(clientId.Value, application);
clientLabels.ApplyToReport(report);
}
}
return(report);
}
}
public static void DeleteExecution(Execution execution)
{
int executionId = int.Parse(execution.Id);
#if MOCKUP
//build the subscriptions path
string path = Path.Combine(System.Configuration.ConfigurationManager.AppSettings["AppDataPathForMockup"], "Executions");
//find the file
string file =
(from f in Directory.GetFiles(path, string.Format("{0}.xml", execution.Id), SearchOption.AllDirectories)
select f)
.FirstOrDefault();
if (file != null)
{
File.Delete(file);
}
//find the data file
string dataPath = Path.Combine(System.Configuration.ConfigurationManager.AppSettings["AppDataPathForMockup"], "ExecutionData");
string dataFile =
(from f in Directory.GetFiles(path, string.Format("{0}.*", execution.Id), SearchOption.AllDirectories)
select f)
.FirstOrDefault();
if (dataFile != null)
{
File.Delete(file);
}
#else
using (var data = new Emdat.InVision.Sql.ReportingDataContext("Emdat.InVision.ReportContent"))
using (var info = new Emdat.InVision.Sql.ReportingDataContext())
{
//transaction here would be distributed (not worth it)
//TODO: need a back-end process cleaning up "orphaned" executions
info.DeleteExecution(executionId);
data.DeleteExecutionData(executionId);
}
#endif
}
public static IEnumerable <Report> ListReports(int userId, ReportingApplication application)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var reports =
from r in sql.ListReports(userId)
orderby r.CategorySortOrder, r.SortOrder
select new Report
{
Id = r.ReportID.ToString(),
Name = r.Name,
Description = r.Description,
ReportingServicesPath = r.ReportPath,
Category = r.CategoryName,
ReportParametersUrl = r.ReportParametersURL,
ReportingEnvironmentId = (ReportingEnvironmentEnum)r.EnvironmentID,
ReportingEnvironmentName = r.EnvironmentName
};
return(reports.ToList());
}
}
/// <summary>
/// Loads the execution data into the specified stream.
/// </summary>
/// <param name="execution">The execution.</param>
/// <param name="stream">The stream.</param>
public static void LoadExecutionData(Execution execution, Stream stream)
{
if (execution == null)
{
throw new ArgumentNullException("execution");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanWrite)
{
throw new InvalidOperationException("Stream is not writable");
}
if (!execution.Application.HasValue)
{
throw new InvalidOperationException("Application must be set");
}
if (string.IsNullOrEmpty(execution.Id))
{
throw new InvalidOperationException("Id must be set");
}
int executionId = int.Parse(execution.Id);
using (var data = new Emdat.InVision.Sql.ReportingDataContext(execution.Application.Value, "Emdat.InVision.ReportContent"))
{
var result = data.GetExecutionData(executionId, stream);
if (result == null)
{
throw new KeyNotFoundException(string.Format("Could not find data for report: {0}", executionId));
}
}
}
/// <summary>
/// Loads the execution data into the specified stream.
/// </summary>
/// <param name="execution">The execution.</param>
public static System.Data.IDataReader LoadExecutionDataReader(Execution execution)
{
if (execution == null)
{
throw new ArgumentNullException("execution");
}
if (!execution.Application.HasValue)
{
throw new InvalidOperationException("Application must be set");
}
if (string.IsNullOrEmpty(execution.Id))
{
throw new InvalidOperationException("Id must be set");
}
int executionId = int.Parse(execution.Id);
using (var data = new Emdat.InVision.Sql.ReportingDataContext(execution.Application.Value, "Emdat.InVision.ReportContent"))
{
return(data.GetExecutionDataReader(executionId));
}
}
public static ClientLabels LoadClientLabels(int clientId, ReportingApplication application)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
return((from l in sql.GetClientLabels(clientId)
select new ClientLabels
{
LabelPatientID = l.LabelPatientID,
LabelPatientName = l.LabelPatientName,
LabelGender = l.LabelGender,
LabelBirthdate = l.LabelBirthdate,
LabelAppointmentDate = l.LabelAppointmentDate,
LabelOrderNumber = l.LabelOrderNumber,
LabelPatientLetter = l.LabelPatientLetter,
LabelUserField1 = l.LabelUserField1,
LabelUserField2 = l.LabelUserField2,
LabelUserField3 = l.LabelUserField3,
LabelUserField4 = l.LabelUserField4,
LabelUserField5 = l.LabelUserField5,
LabelBillingUnit = l.LabelBillingUnit,
LabelDictator = l.LabelDictator
}).FirstOrDefault());
}
}
public static void AddExecution(Execution execution, byte[] reportData)
{
#region validation
if (execution == null)
{
throw new ArgumentNullException("execution");
}
if (reportData == null)
{
throw new ArgumentNullException("reportData");
}
if (!execution.Application.HasValue)
{
throw new InvalidOperationException("Application must be set");
}
if (execution.Application.Value == ReportingApplication.InCommand &&
!execution.CompanyId.HasValue)
{
throw new InvalidOperationException("CompanyId must be set for InCommand reports");
}
if (string.IsNullOrEmpty(execution.OwnerId))
{
throw new InvalidOperationException("OwnerId must be set");
}
if (string.IsNullOrEmpty(execution.ReportId))
{
throw new InvalidOperationException("ReportId must be set");
}
if (string.IsNullOrEmpty(execution.FormatId))
{
throw new InvalidOperationException("FormatId must be set");
}
if (execution.Parameters == null)
{
}
#endregion
int reportingUserId = int.Parse(execution.OwnerId);
int reportId = int.Parse(execution.ReportId);
int reportFormatId = int.Parse(execution.FormatId);
using (var data = new Emdat.InVision.Sql.ReportingDataContext(execution.Application.Value, "Emdat.InVision.ReportContent"))
using (var info = new Emdat.InVision.Sql.ReportingDataContext(execution.Application.Value))
{
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required))
{
//add the new execution record
var result = (info.AddExecution(
reportingUserId,
execution.CompanyId,
execution.Description,
execution.ActualCompletionTime,
reportId,
reportFormatId,
ReportParametersHelper.GetParameterValuesXml(execution.Parameters),
false,
execution.ModifiedUser,
execution.ModifiedDate,
(int)execution.ReportingEnvironmentId)).FirstOrDefault();
if (result == null || !result.ReportExecutionID.HasValue)
{
throw new ApplicationException(string.Format("Unable to add execution '{0}'. The procedure did not return a new ID.", execution.Description));
}
//avoid using a distributed transaction
//if the following write fails, the outer transaction will get rolled back
using (TransactionScope noTs = new TransactionScope(TransactionScopeOption.Suppress))
{
//add the report content
var rowsAffected = data.SetExecutionData(result.ReportExecutionID.Value, execution.FormatFileType, reportData);
if (rowsAffected < 1)
{
throw new ApplicationException("SetExecutionData failed. No rows were affected");
}
noTs.Complete();
}
//complete the outer transaction
ts.Complete();
}
}
}
public static Subscription LoadSubscription(string id, int userId, ReportingApplication application)
{
#region validation
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
int subscriptionId = int.Parse(id);
if (subscriptionId < 1)
{
throw new ArgumentOutOfRangeException("id");
}
#endregion
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var subscription =
(from s in sql.GetSubscription(subscriptionId)
let next = sql.GetSubscriptionNextExecution(s.ReportSubscriptionID).FirstOrDefault()
let prev = sql.GetSubscriptionPreviousExecution(s.ReportSubscriptionID).FirstOrDefault()
let notifications = sql.GetSubscriptionNotifications(s.ReportSubscriptionID)
let notificationEmail =
(notifications.Any(n => n.ReportNotificationTypeID == 2) && !String.IsNullOrEmpty(notifications.FirstOrDefault(n => n.ReportNotificationTypeID == 2).ReportNotificationOptions)) ?
XDocument.Parse(notifications.FirstOrDefault(n => n.ReportNotificationTypeID == 2).ReportNotificationOptions).Element("NotificationOptions").Element("EmailAddress").Value : string.Empty
let schedule = new Schedule(
s.ScheduleFrequencyID,
s.FrequencyInterval,
s.FrequencyRecurrenceFactor,
s.FrequencyRelativeInterval,
next != null ? next.ScheduledStartDate : prev != null ? prev.ScheduledStartDate : null,
s.StartTime,
s.EndTime)
select new Subscription
{
Application = application,
OwnerId = userId.ToString(),
Description = s.Name,
FormatId = s.ReportFormatID.ToString(),
Id = s.ReportSubscriptionID.ToString(),
IsActive = s.IsActive,
ErrorDescription = prev != null ? prev.ReportExecutionErrorDescription : null,
LastRunEndTime = prev != null ? prev.EndDate : null,
LastRunScheduledTime = prev != null ? prev.ScheduledStartDate : null,
LastRunStartTime = prev != null ? prev.StartDate : null,
ModifiedDate = s.ModifiedDate,
ModifiedUser = s.ModifiedUser,
NextRunTime = next != null ? next.ScheduledStartDate : null,
Parameters = ReportParametersHelper.GetParameterValuesFromXml(s.Parameters),
ReportingEnvironmentId = (ReportingEnvironmentEnum)s.EnvironmentID,
ReportingEnvironmentName = s.EnvironmentName,
ReportId = s.ReportID.ToString(),
NotifyOnScreen = notifications.Any(n => n.ReportNotificationTypeID == 1),
NotifyEmail = notifications.Any(n => n.ReportNotificationTypeID == 2),
NotificationEmail = notificationEmail,
ScheduleOptionId = next != null && next.ScheduledStartDate.HasValue ? ScheduleOptionEnum.Schedule :
schedule.RecurrenceOption == ScheduleRecurrence.Once ? ScheduleOptionEnum.QueueNow :
false == s.IsActive ? ScheduleOptionEnum.Schedule :
ScheduleOptionEnum.QueueNow,
Schedule = schedule,
StatusId = s.IsActive ? GetSubscriptionStatus(prev, next) : ExecutionStatusEnum.Inactive,
Options = s.Options
}).FirstOrDefault();
if (subscription == null)
{
throw new KeyNotFoundException(string.Format("The report subscription could not be found: {0}", id));
}
return(subscription);
}
}
public static void AddSubscription(Subscription subscription)
{
#region validation
if (!subscription.Application.HasValue)
{
throw new InvalidOperationException("Application must be set");
}
//for InCommand, require a company ID
if (subscription.Application.Value == ReportingApplication.InCommand &&
!subscription.CompanyId.HasValue)
{
throw new InvalidOperationException("CompanyId is required for InCommand reports");
}
if (string.IsNullOrEmpty(subscription.FormatId))
{
throw new InvalidOperationException("Format must be set");
}
if (string.IsNullOrEmpty(subscription.ReportId))
{
throw new InvalidOperationException("ReportId must be set");
}
if (subscription.Parameters == null)
{
throw new InvalidOperationException("Parameters must be set");
}
//TODO: validate the parameters
if (subscription.Schedule == null)
{
throw new InvalidOperationException("Schedule must be set");
}
//TODO: validate the schedule
#endregion
//set input values for the insert operation
int reportingUserId = int.Parse(subscription.OwnerId);
int reportId = int.Parse(subscription.ReportId);
int formatId = int.Parse(subscription.FormatId);
//get next run info
NextRunInfo nextRunInfo = subscription.GetNextRunInfo(DateTime.Now);
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(subscription.Application.Value))
{
var result = sql.AddSubscription(
reportingUserId,
subscription.CompanyId,
reportId,
subscription.Description,
formatId,
subscription.IsActive,
subscription.GetParameterValuesXml(),
subscription.Schedule.GetFrequencyId(),
subscription.Schedule.GetFrequencyInterval(),
subscription.Schedule.GetFrequencyRecurrenceFactor(),
subscription.Schedule.GetFrequencyRelativeInterval(),
string.Format("{0:00}{1:00}{2:00}",
subscription.Schedule.StartTime.Hours,
subscription.Schedule.StartTime.Minutes,
subscription.Schedule.StartTime.Seconds),
string.Format("{0:00}{1:00}{2:00}",
subscription.Schedule.EndTime.Hours,
subscription.Schedule.EndTime.Minutes,
subscription.Schedule.EndTime.Seconds),
nextRunInfo.Date,
nextRunInfo.ParametersAsXml,
subscription.ModifiedUser,
DateTime.Now,
subscription.NotifyOnScreen,
subscription.NotifyEmail,
subscription.NotificationEmail,
subscription.Options,
(int)subscription.ReportingEnvironmentId).FirstOrDefault();
if (result == null || !result.ReportSubscriptionID.HasValue)
{
throw new ApplicationException("The subscription could not be added. The procedure did not return a result.");
}
}
}
public static void UpdateSubscription(Subscription subscription)
{
#region validation
if (!subscription.Application.HasValue)
{
throw new InvalidOperationException("Application must be set");
}
if (string.IsNullOrEmpty(subscription.FormatId))
{
throw new InvalidOperationException("Format must be set");
}
if (string.IsNullOrEmpty(subscription.ReportId))
{
throw new InvalidOperationException("ReportId must be set");
}
if (subscription.Parameters == null)
{
throw new InvalidOperationException("Parameters must be set");
}
if (subscription.Schedule == null)
{
throw new InvalidOperationException("Schedule must be set");
}
#endregion
//set input values for the insert operation
int reportingUserId = int.Parse(subscription.OwnerId);
int subscriptionId = int.Parse(subscription.Id);
int reportId = int.Parse(subscription.ReportId);
int formatId = int.Parse(subscription.FormatId);
//get next run info
NextRunInfo nextRunInfo = subscription.GetNextRunInfo(DateTime.Now);
//load old values
Subscription oldSubscription = LoadSubscription(
subscription.Id,
reportingUserId,
subscription.Application.Value);
//only change the properties that are not "read-only"
oldSubscription.Application = subscription.Application;
oldSubscription.FormatId = subscription.FormatId;
oldSubscription.IsActive = subscription.IsActive;
oldSubscription.ModifiedDate = DateTime.Now;
oldSubscription.ModifiedUser = subscription.ModifiedUser;
oldSubscription.Description = subscription.Description;
oldSubscription.Parameters = subscription.Parameters;
oldSubscription.Schedule = subscription.Schedule;
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(subscription.Application.Value))
{
int result = sql.EditSubscription(
reportingUserId,
subscriptionId,
reportId,
subscription.Description,
formatId,
subscription.IsActive,
subscription.GetParameterValuesXml(),
subscription.Schedule.GetFrequencyId(),
subscription.Schedule.GetFrequencyInterval(),
subscription.Schedule.GetFrequencyRecurrenceFactor(),
subscription.Schedule.GetFrequencyRelativeInterval(),
string.Format("{0:00}{1:00}{2:00}",
subscription.Schedule.StartTime.Hours,
subscription.Schedule.StartTime.Minutes,
subscription.Schedule.StartTime.Seconds),
string.Format("{0:00}{1:00}{2:00}",
subscription.Schedule.EndTime.Hours,
subscription.Schedule.EndTime.Minutes,
subscription.Schedule.EndTime.Seconds),
nextRunInfo.Date,
nextRunInfo.ParametersAsXml,
subscription.ModifiedUser,
DateTime.Now,
subscription.NotifyOnScreen,
subscription.NotifyEmail,
subscription.NotificationEmail,
subscription.Options,
(int)subscription.ReportingEnvironmentId);
if (result < 1)
{
throw new ApplicationException("The subscription was not updated. No rows were modified.");
}
}
}
public static IEnumerable <ReportFormat> ListReportFormats()
{
#if MOCKUP
return(new ReportFormat[]
{
new ReportFormat
{
Id = "1",
Name = "Comma Separated Values",
FileExtension = "csv",
Description = "",
IsActive = true,
Value = "CSV"
},
new ReportFormat
{
Id = "2",
Name = "HTML",
FileExtension = "html",
Description = "",
IsActive = true,
Value = "HTML"
},
new ReportFormat
{
Id = "3",
Name = "Adobe PDF",
FileExtension = "pdf",
Description = "",
IsActive = true,
Value = "PDF"
},
new ReportFormat
{
Id = "1",
Name = "XML",
FileExtension = "xml",
Description = "",
IsActive = true,
Value = "XML"
}
});
#else
if (_formats == null ||
_expireTime < DateTime.Now)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext())
{
var formats =
from f in sql.ListFormats()
where f.IsActive
orderby f.Name
select new ReportFormat
{
Id = f.ReportFormatID.ToString(),
Name = f.Name,
Description = f.Description,
IsActive = f.IsActive,
Value = f.SSRSFormat,
FileExtension = f.Extension,
HttpContentType = f.HTTPContentType,
DeviceInfo = f.SSRSDeviceInfo
};
_formats = formats.ToList();
_expireTime = DateTime.Now.AddMinutes(5);
}
}
return(_formats);
#endif
}
public static IEnumerable <Execution> ListExecutions(int userId, int?companyId, ReportingApplication application, ICacheProvider cache, bool forceRefresh)
{
IEnumerable <Execution> executions = null;
#region caching
string cacheKey = string.Format("Emdat.InVision.Execution.ListExecutions({0},{1},{2})", userId, companyId, application);
if (!forceRefresh && cache != null)
{
executions = cache[cacheKey] as IEnumerable <Execution>;
}
#endregion
if (executions == null)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var executionsQuery =
from e in sql.ListExecutions(userId, companyId)
let prms = ReportParametersHelper.GetParameterValuesFromXml(e.Parameters)
//let startDatePrm = (from p in prms where p.Name == "Start_Date" select p.Value).FirstOrDefault()
//let endDatePrm = (from p in prms where p.Name == "End_Date" select p.Value).FirstOrDefault()
where e.ReportExecutionStatusID != (int)ExecutionStatusEnum.Running
select new Execution
{
Application = application,
OwnerId = e.OwnerID.ToString(),
OwnerName = string.Format("{0}, {1}", e.OwnerNameLast, e.OwnerNameFirst),
OwnerUsername = e.OwnerUsername,
Id = e.ReportExecutionID.ToString(),
ActualCompletionTime = e.EndDate,
ActualStartTime = e.StartDate,
Description = e.Name, //string.Format("{0} ({1} - {2})", e.Name, startDatePrm, endDatePrm),
ExpirationDate = e.ExpirationDate,
FormatId = e.ReportFormatID.ToString(),
Parameters = prms,
ReportingEnvironmentId = (ReportingEnvironmentEnum)e.EnvironmentID,
ReportingEnvironmentName = e.EnvironmentName,
ReportId = e.ReportID.ToString(),
ScheduledRunTime = e.ScheduledStartDate,
SubscriptionId = e.ReportSubscriptionID.ToString(),
StatusId = (ExecutionStatusEnum)e.ReportExecutionStatusID,
ErrorName = e.ErrorName,
ErrorDescription = e.ErrorDescription
};
executions = executionsQuery.ToList();
#region caching
//add to cache
if (cache != null)
{
cache.Add(cacheKey, executions, CacheDuration);
}
#endregion
}
}
return(executions);
}
public static IEnumerable <Subscription> ListSubscriptions(int userId, int?companyId, ReportingApplication application, ICacheProvider cache, bool forceRefresh)
{
IEnumerable <Subscription> subscriptions = null;
#region caching
string cacheKey = string.Format("Emdat.InVision.Subscription.ListSubscriptions({0},{1},{2})", userId, companyId, application);
if (!forceRefresh && cache != null)
{
subscriptions = cache[cacheKey] as IEnumerable <Subscription>;
}
#endregion
if (subscriptions == null)
{
using (var sql = new Emdat.InVision.Sql.ReportingDataContext(application))
{
var subscriptionsQuery =
from s in sql.ListSubscriptions(userId, companyId)
let next = sql.GetSubscriptionNextExecution(s.ReportSubscriptionID).FirstOrDefault()
let prev = sql.GetSubscriptionPreviousExecution(s.ReportSubscriptionID).FirstOrDefault()
select new Subscription
{
Application = application,
OwnerId = s.OwnerID.ToString(),
OwnerName = string.Format("{0}, {1}", s.OwnerNameLast, s.OwnerNameFirst),
OwnerUsername = s.OwnerUsername,
Description = s.Name,
FormatId = s.ReportFormatID.ToString(),
Id = s.ReportSubscriptionID.ToString(),
IsActive = s.IsActive,
ErrorDescription = prev != null ? prev.ReportExecutionErrorDescription : null,
LastRunEndTime = prev != null ? prev.EndDate : null,
LastRunScheduledTime = prev != null ? prev.ScheduledStartDate : null,
LastRunStartTime = prev != null ? prev.StartDate : null,
ModifiedDate = s.ModifiedDate,
ModifiedUser = s.ModifiedUser,
NextRunTime = next != null ? next.ScheduledStartDate : null,
Parameters = ReportParametersHelper.GetParameterValuesFromXml(s.Parameters),
ReportingEnvironmentId = (ReportingEnvironmentEnum)s.EnvironmentID.GetValueOrDefault(1),
ReportingEnvironmentName = s.EnvironmentName,
ReportId = s.ReportID.ToString(),
// ScheduleOption = ???,
Schedule = new Schedule(
s.ScheduleFrequencyID,
s.FrequencyInterval,
s.FrequencyRecurrenceFactor,
s.FrequencyRelativeInterval,
next != null ? next.ScheduledStartDate : null,
s.StartTime,
s.EndTime),
StatusId = s.IsActive ? GetSubscriptionStatus(prev, next) : ExecutionStatusEnum.Inactive,
Options = s.Options
};
subscriptions = subscriptionsQuery.ToList();
#region caching
//add to cache
if (cache != null)
{
cache.Add(cacheKey, subscriptions, CacheDuration);
}
#endregion
}
}
return(subscriptions);
}