public UriParametersFilter(ICommunicationContext context, IErrorCollector collector)
{
_context = context;
Logger = NullLogger.Instance;
Errors = collector;
_pipelineData = context.PipelineData;
}
public CompoundOperationFilter(IRequest request, IUriResolver uriResolver, ICommunicationContext context,
IErrorCollector errorCollector)
{
_httpMethodFilter = new HttpMethodOperationFilter(request);
_uriNameFilter = new UriNameOperationFilter(context, uriResolver);
_uriParametersFilter = new UriParametersFilter(context, errorCollector);
}
public static void AddErrors(this IErrorCollector collector, IEnumerable <string> errors)
{
foreach (var error in errors)
{
collector.AddError(error);
}
}
public ExportService(IErrorCollector errorCollector)
{
if (errorCollector == null)
{
throw new ArgumentException("ExportService dependencies cannot be NULL.");
}
this._errorCollector = errorCollector;
}
public ApiControllerBase(IErrorCollector errorCollector)
{
if (errorCollector == null)
{
throw new ArgumentNullException("ApiControllerBase dependencies cannot be null.");
}
ErrorCollector = errorCollector;
}
public static GenericResponse <T> FromErrorCollector(IErrorCollector errorCollector, int code)
{
return(new GenericResponse <T>
{
Result = default(T),
Code = code,
Errors = errorCollector.Errors.Select((x) => new ErrorMessage(x.Code, x.Message, x.Type)).ToArray()
});
}
public SignInUseCase(IValidator <UserLoginModel> validator, IIdentityProvider identityProvider, ISignInExecutor signInExecutor, INavigator navigator, IErrorCollector errorCollector, SignInErrorCreator errorCreator)
{
this.validator = validator;
this.identityProvider = identityProvider;
this.signInExecutor = signInExecutor;
this.navigator = navigator;
this.errorCollector = errorCollector;
this.errorCreator = errorCreator;
}
public ExternalServiceBase(IErrorCollector errorCollector, IRestWebClient webClient)
{
if (errorCollector == null || webClient == null)
{
throw new ArgumentNullException("External Service dependencies cannot be null.");
}
_webClient = webClient;
_errorCollector = errorCollector;
}
public int GetFieldIndex(string name, IErrorCollector errors)
{
var index = this.GetFieldIndex(name, false);
if (index == -1)
{
errors.AddIsRequiredError(name);
}
return(index);
}
private IErrorCollector GetPrimaryErrorCollector()
{
IErrorCollector primaryErrorCollector = GetPackageErrorCollectorIfAny();
if (primaryErrorCollector != null)
{
return(primaryErrorCollector);
}
return(this._bundleErrorCollector);
}
private IErrorCollector GetPackageErrorCollectorIfAny()
{
IErrorCollector package = null;
if (this._rollbarPackage != null)
{
package = this._rollbarPackage as IErrorCollector;
}
return(package);
}
public ProductService(IProductRepository repository,
IErrorCollector errorCollector,
IExportService exportService)
{
if (repository == null ||
errorCollector == null ||
exportService == null)
{
throw new ArgumentException("ProductService dependencies cannot be NULL.");
}
this._repository = repository;
this._errorCollector = errorCollector;
this._exportService = exportService;
}
/// <summary>
/// Gets the rollbar package.
/// </summary>
/// <returns>IRollbarPackage.</returns>
private IRollbarPackage GetRollbarPackage()
{
if (this._rollbarPackage == null)
{
this._rollbarPackage = CreateRollbarPackage(this._payloadObject);
if (this._rollbarPackage != null)
{
IErrorCollector packageErrorCollector = this._rollbarPackage as IErrorCollector;
if (packageErrorCollector != null)
{
foreach (var exception in this._bundleErrorCollector.Exceptions)
{
packageErrorCollector.Register(exception);
}
}
}
}
this._rollbarPackage = ApplyConfigPackageDecorator(this._rollbarPackage);
return(this._rollbarPackage);
}
/// <summary>
/// Reports the specified rollbar logger.
/// </summary>
/// <param name="rollbarLogger">The rollbar logger.</param>
/// <param name="dataObject">The data object.</param>
/// <param name="rollbarError">The rollbar error.</param>
/// <param name="message">The message.</param>
/// <param name="exception">The exception.</param>
/// <param name="errorCollector">The error collector.</param>
public static void Report(
RollbarLogger rollbarLogger,
object dataObject,
InternalRollbarError rollbarError,
string message,
Exception exception,
IErrorCollector errorCollector
)
{
var rollbarException = new RollbarException(rollbarError, message ?? rollbarError.ToString(), exception);
errorCollector?.Register(rollbarException);
var rollbarEvent = new InternalErrorEventArgs(rollbarLogger, dataObject, rollbarException, rollbarException.Message);
if (rollbarLogger != null)
{
rollbarLogger.OnRollbarEvent(rollbarEvent);
}
else
{
RollbarQueueController.Instance.OnRollbarEvent(rollbarEvent);
}
}
public UriParametersFilter(ICommunicationContext context, IErrorCollector collector)
{
this.Logger = NullLogger.Instance;
this.Errors = collector;
this.pipelineData = context.PipelineData;
}
public ProductController(IProductService service, IErrorCollector errorCollector)
: base(errorCollector)
{
_service = service;
}
public UriParametersFilter(ICommunicationContext context, IErrorCollector collector)
{
Logger = NullLogger.Instance;
Errors = collector;
_environment = context.Environment;
}
public UriParametersFilter(ICommunicationContext context, IErrorCollector collector)
{
Logger = NullLogger.Instance;
Errors = collector;
_environment = context.Environment;
}
public static void CopyErrorsFrom(this IErrorCollector collector, IUserMessages messages)
{
collector.AddErrors(messages.GetUserMessages());
}
public static void AddIsRequiredError(this IErrorCollector collector, string name)
{
collector.AddError(string.Format("'{0}' is required.", name));
}
public ProductApiClient(IRestWebClient webClient, IErrorCollector errorCollector)
: base(errorCollector, webClient)
{
ServiceUrl = ConfigurationManager.AppSettings["ProductApiUrl"];
}
