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);
}
public async Task <ActionResult> ListIgnoredExceptions(IgnoredExceptionParameters parameters)
{
ValidateIgnoredExceptionParameters(parameters, IgnoredExceptionParametersValidator.NoValidation);
var filter = new IgnoredExceptionFilter()
{
FilterMessage = parameters.FilterMessage,
CarLine = parameters.CarLine,
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
Action = IgnoredExceptionAction.Exceptions
};
filter.InitialiseFromJson(parameters);
var results = await IgnoredExceptionViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.IgnoredExceptions.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public async Task <ActionResult> ModalContent(IgnoredExceptionParameters parameters)
{
ValidateIgnoredExceptionParameters(parameters, IgnoredExceptionParametersValidator.Action);
var filter = IgnoredExceptionFilter.FromParameters(parameters);
var ignoredExceptionView = await IgnoredExceptionViewModel.GetModel(DataContext, filter);
return(PartialView(GetContentPartialViewName(parameters.Action), ignoredExceptionView));
}
public async Task <ActionResult> IgnoredExceptionPage(IgnoredExceptionParameters parameters)
{
var filter = new IgnoredExceptionFilter()
{
PageIndex = PageIndex,
PageSize = PageSize
};
return(View(await IgnoredExceptionViewModel.GetModel(DataContext, filter)));
}
public async Task <ActionResult> ContextMenu(IgnoredExceptionParameters parameters)
{
ValidateIgnoredExceptionParameters(parameters, IgnoredExceptionParametersValidator.IgnoredExceptionIdentifier);
var filter = IgnoredExceptionFilter.FromParameters(parameters);
filter.Action = IgnoredExceptionAction.Exception;
var ignoredExceptionView = await IgnoredExceptionViewModel.GetModel(DataContext, filter);
return(PartialView("_ContextMenu", ignoredExceptionView));
}
private static IgnoredExceptionViewModel GetFullAndPartialViewModel(IDataContext context,
IgnoredExceptionFilter filter)
{
var model = new IgnoredExceptionViewModel(SharedModelBase.GetBaseModel(context))
{
Configuration = context.ConfigurationSettings,
};
HydrateModelWithCommonProperties(model, context);
return(model);
}
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);
}
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);
}
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);
}
private async Task <IgnoredExceptionViewModel> GetModelFromParameters(IgnoredExceptionParameters parameters)
{
return(await IgnoredExceptionViewModel.GetModel(DataContext, IgnoredExceptionFilter.FromParameters(parameters)));
}
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 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)));
}
