private static async Task<IgnoredExceptionViewModel> GetFullAndPartialViewModelForIgnoredException
(
IDataContext context,
IgnoredExceptionFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new IgnoredExceptionViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var ignoredException = await context.Import.GetFdpImportErrorExclusion(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = ignoredException.ProgrammeId,
Gateway = ignoredException.Gateway,
Code = model.IgnoredException.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
if (!(ignoredException is EmptyFdpImportErrorExclusion))
{
ignoredException.Programme = model.Programmes.FirstOrDefault(p => p.Id == ignoredException.ProgrammeId.GetValueOrDefault());
ignoredException.Document =
model.Documents.FirstOrDefault(d => d.Id == ignoredException.DocumentId.GetValueOrDefault());
}
model.IgnoredException = ignoredException;
return model;
}
private static IgnoredExceptionViewModel GetFullAndPartialViewModel(IDataContext context,
IgnoredExceptionFilter filter)
{
var model = new IgnoredExceptionViewModel(SharedModelBase.GetBaseModel(context))
{
Configuration = context.ConfigurationSettings,
};
HydrateModelWithCommonProperties(model, context);
return model;
}
public static async Task<IgnoredExceptionViewModel> GetModel(IDataContext context,
IgnoredExceptionFilter filter)
{
IgnoredExceptionViewModel model = null;
if (filter.Action == IgnoredExceptionAction.Delete
|| filter.Action == IgnoredExceptionAction.Exception)
{
model = await GetFullAndPartialViewModelForIgnoredException(context, filter);
}
else if (filter.Action == IgnoredExceptionAction.Exceptions)
{
model = await GetFullAndPartialViewModelForIgnoredExceptions(context, filter);
}
else
{
model = GetFullAndPartialViewModel(context, filter);
}
if (filter.Action != IgnoredExceptionAction.NotSet)
{
model.IdentifierPrefix = Enum.GetName(filter.Action.GetType(), filter.Action);
}
return model;
}
public async Task<PagedResults<FdpImportErrorExclusion>> ListFdpIgnoredExceptions(IgnoredExceptionFilter filter)
{
return await Task.FromResult(_importDataStore.FdpImportErrorExclusionGetMany(filter));
}
public async Task<FdpImportErrorExclusion> GetFdpImportErrorExclusion(IgnoredExceptionFilter filter)
{
return await Task.FromResult(_importDataStore.FdpImportErrorExclusionGet(filter));
}
private static async Task<IgnoredExceptionViewModel> GetFullAndPartialViewModelForIgnoredExceptions
(
IDataContext context,
IgnoredExceptionFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new IgnoredExceptionViewModel(baseModel)
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter() {
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.IgnoredExceptions = await context.Import.ListFdpIgnoredExceptions(filter);
model.TotalPages = model.IgnoredExceptions.TotalPages;
model.TotalRecords = model.IgnoredExceptions.TotalRecords;
model.TotalDisplayRecords = model.IgnoredExceptions.TotalDisplayRecords;
foreach (var ignoredException in model.IgnoredExceptions.CurrentPage)
{
ignoredException.Programme = model.Programmes.FirstOrDefault(p => p.Id == ignoredException.ProgrammeId.GetValueOrDefault());
ignoredException.Document =
model.Documents.FirstOrDefault(d => d.Id == ignoredException.DocumentId.GetValueOrDefault());
}
return model;
}
public PagedResults<FdpImportErrorExclusion> FdpImportErrorExclusionGetMany(IgnoredExceptionFilter filter)
{
PagedResults<FdpImportErrorExclusion> retVal = null;
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
var totalRecords = 0;
var totalDisplayRecords = 0;
if (!string.IsNullOrEmpty(filter.CarLine))
{
para.Add("@CarLine", filter.CarLine, DbType.String);
}
if (!string.IsNullOrEmpty(filter.ModelYear))
{
para.Add("@ModelYear", filter.ModelYear, DbType.String);
}
if (!string.IsNullOrEmpty(filter.Gateway))
{
para.Add("@Gateway", filter.Gateway, DbType.String);
}
if (filter.PageIndex.HasValue)
{
para.Add("@PageIndex", filter.PageIndex.Value, DbType.Int32);
}
if (filter.PageSize.HasValue)
{
para.Add("@PageSize", filter.PageSize.HasValue ? filter.PageSize.Value : 10, DbType.Int32);
}
if (filter.SortIndex.HasValue)
{
para.Add("@SortIndex", filter.SortIndex.Value, DbType.Int32);
}
if (filter.SortDirection != enums.SortDirection.NotSet)
{
var direction = filter.SortDirection == enums.SortDirection.Descending ? "DESC" : "ASC";
para.Add("@SortDirection", direction, DbType.String);
}
para.Add("@TotalPages", dbType: DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalRecords", dbType: DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalDisplayRecords", dbType: DbType.Int32, direction: ParameterDirection.Output);
var results = conn.Query<FdpImportErrorExclusion>("dbo.Fdp_ImportErrorExclusion_GetMany", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
totalRecords = para.Get<int>("@TotalRecords");
totalDisplayRecords = para.Get<int>("@TotalDisplayRecords");
}
retVal = new PagedResults<FdpImportErrorExclusion>
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
TotalRecords = totalRecords,
TotalDisplayRecords = totalDisplayRecords,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : totalRecords
};
var currentPage = new List<FdpImportErrorExclusion>();
foreach (var result in results)
{
currentPage.Add(result);
}
retVal.CurrentPage = currentPage;
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public FdpImportErrorExclusion FdpImportErrorExclusionGet(IgnoredExceptionFilter filter)
{
FdpImportErrorExclusion retVal = new EmptyFdpImportErrorExclusion();
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpImportErrorExclusionId", filter.IgnoredExceptionId.GetValueOrDefault(), DbType.Int32);
var results = conn.Query<FdpImportErrorExclusion>("Fdp_ImportErrorExclusion_Get", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
retVal = results.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
