public override void Configure(Container container)
{
RequestFilters.Add((req, resp, requestDto) => {
var log = LogManager.GetLogger(GetType());
log.Info(string.Format("REQ {0}: {1} {2} {3} {4} {5}", DateTimeOffset.Now.Ticks, req.HttpMethod,
req.OperationName, req.RemoteIp, req.RawUrl, req.UserAgent));
});
ResponseFilters.Add((req, resp, dto) => {
var log = LogManager.GetLogger(GetType());
log.Info(string.Format("RES {0}: {1} {2}", DateTimeOffset.Now.Ticks, resp.StatusCode,
resp.ContentType));
});
JsConfig.DateHandler = JsonDateHandler.ISO8601;
Plugins.Add(new RequestLogsFeature());
ConfigureQueues(container);
var config = new EndpointHostConfig();
if (m_debugEnabled)
{
config.DebugMode = true;
config.WriteErrorsToResponse = true;
config.ReturnsInnerException = true;
}
SetConfig(config);
}
public override void Configure(Container container)
{
// Force a response type of JSON.
RequestFilters.Add(
(IHttpRequest httpReq, IHttpResponse httpResp, object requestDto) =>
{
var sessionId = httpReq.ResponseContentType = "text/json";
});
ResponseFilters.Add((IHttpRequest request, IHttpResponse response, object dto) =>
{
var statusCode = dto as string;
if (statusCode != null)
{
response.StatusCode = int.Parse(statusCode);
}
var dict = dto as Dictionary <string, object>;
if (dict != null)
{
var val = dict["value"];
var json = val as JsonObject;
if (json != null)
{
Logger.Info(JsonSerializer.SerializeToString(json));
}
else
{
Logger.Info(val.ToString());
}
}
});
}
public static IQueryable <T> ApplyFilters <T>(this IQueryable <T> query, RequestFilters filters)
{
if (filters != null)
{
if (filters.Filters.Any())
{
var predicate = new StringBuilder();
var propertyValues = filters.Filters.Select(f => f.Value).ToArray();
for (int i = 0; i < filters.Filters.Count; i++)
{
if (filters.Filters[i].Path == "rating")
{
continue;
}
if (i > 0)
{
predicate.Append($" {filters.LogicalOperator} ");
}
predicate.Append($"{filters.Filters[i].Path} {filters.Filters[i].Action} ({propertyValues[i]})");
}
query = query.Where(predicate.ToString());
}
}
return(query);
}
public async Task <IEnumerable <TriggeredEvent> > SearcAlerts(RequestFilters filters)
{
var currentAlerts = await _apiService.GetCurrentAlertsAsync(filters?.MinutesLookback);
if (filters != null)
{
currentAlerts = ProcessAlertsWithFilters(currentAlerts, filters);
}
var alertTypes = await _databaseService.GetAlertTypesByIdsAsync(currentAlerts.Events.Select(x => x.Alert_Type_Id).Concat(currentAlerts.Ranges.Select(x => x.Alert_Type_Id)).Distinct());
var capturedPCs = await _databaseService.GetCapturedPCsByIdsAsync(currentAlerts.Events.Select(x => x.Capture_PC_Id).Concat(currentAlerts.Ranges.Select(x => x.Capture_PC_Id)).Distinct());
var recordings = await _databaseService.GetRecordingsByIdsAsync(currentAlerts.Events.Select(x => x.Recording_Id).Concat(currentAlerts.Ranges.Select(x => x.Recording_Id)).Distinct());
var countries = await _databaseService.GetCountriesByCodesAsync(capturedPCs.Select(x => x.CountryCode));
var events = ProcessEvents(currentAlerts, alertTypes, capturedPCs, recordings, countries);
var ranges = ProcessRanges(currentAlerts, alertTypes, capturedPCs, recordings, countries);
if (filters != null && !string.IsNullOrWhiteSpace(filters.CountryCode))
{
events = events.Where(x => x.Country == filters.CountryCode);
ranges = ranges.Where(x => x.Country == filters.CountryCode);
}
return(events.Concat(ranges));
}
/// <summary>
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// </summary>
public override void Configure(Container container)
{
JsConfig.EmitCamelCaseNames = true;
container.Register <IUserUnitOfWork>(new UserUnitOfWork());
container.Register <IUserRepository>(new UserRepository(new UserUnitOfWork()));
container.Register <IUserBusinessLogic>(new UserBusinessLogic(new UserRepository(new UserUnitOfWork())));
container.Register <ITaskUnitOfWork>(new TaskUnitOfWork());
container.Register <ITaskRepository>(new TaskRepository(new TaskUnitOfWork()));
//container.Register<ITaskBusinessLogic>(new TaskBusinessLogic(new TaskRepository(new TaskUnitOfWork()),
// new TaskCategoryRepository(new TaskCategoryUnitOfWork())));
container.Register <ITaskBusinessLogic>(new TaskBusinessLogic(new TaskRepository(new TaskUnitOfWork())));
container.Register <ITaskCategoryUnitOfWork>(new TaskCategoryUnitOfWork());
container.Register <ITaskCategoryRepository>(new TaskCategoryRepository(new TaskCategoryUnitOfWork()));
container.Register <ITaskCategoryBusinessLogic>(new TaskCategoryBusinessLogic(new TaskCategoryRepository(new TaskCategoryUnitOfWork())));
this.Plugins.Add(new CorsFeature());
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
if (httpReq.HttpMethod == "OPTIONS")
{
httpRes.AddHeader("Access-Control-Allow-Methods", "POST, GET,DELETE, OPTIONS");
httpRes.AddHeader("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Accept, X-ApiKey");
httpRes.EndRequest();
}
});
}
public RequestsViewModel(IQueryable<Request> requests, int pageNo, int pageSize, User user, RequestFilters requestFilter)
{
User = user;
RequestFilter = requestFilter;
CurrentPage = pageNo;
PageSize = pageSize;
TotalResults = requests.Count();
TotalPages = (int)Math.Ceiling(TotalResults / (float)PageSize);
if (TotalPages > CurrentPage)
{
NextPage = CurrentPage + 1;
}
if (CurrentPage > 1)
{
PreviousPage = CurrentPage - 1;
}
Count = (TotalResults > pageNo * pageSize) ? pageSize : TotalResults - (pageNo - 1) * pageSize;
if (Count > 0)
{
Requests = requests.Skip((pageNo - 1) * pageSize).Take(Count).AsEnumerable().Select(i => new RequestViewModel(user, i));
}
else
{
Count = 0;
Requests = new List<RequestViewModel>();
}
}
public override void Configure(Container container)
{
SetConfig(new EndpointHostConfig {
ServiceStackHandlerFactoryPath = "api"
});
//Set JSON web services to return idiomatic JSON camelCase properties
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
ServiceStack.Text.JsConfig.DateHandler = JsonDateHandler.ISO8601;
Plugins.Add(new CorsFeature()); //Registers global CORS Headers
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
//Handles Request and closes Responses after emitting global HTTP Headers
if (httpReq.HttpMethod == "OPTIONS")
{
httpRes.EndServiceStackRequest();
}
});
//Enable the validation feature
Plugins.Add(new ValidationFeature());
//This method scans the assembly for validators
container.RegisterValidators(typeof(AppHost).Assembly);
container.Register <ICacheClient>(new MemoryCacheClient());
// register RavenDB dependencies
ConfigureRavenDb(container);
// register authentication framework
ConfigureAuthentication(container);
}
public IRequestFilter GetFilter(string name)
{
IRequestFilter result;
RequestFilters.TryGetValue(name, out result);
return(result);
}
public override void Configure(Container container)
{
LoadConfigEnv();
RequestFilters.Add((req, resp, requestDto) => {
var log = LogManager.GetLogger(GetType());
log.Info(string.Format("REQ {0}: {1} {2} {3} {4} {5}", DateTimeOffset.Now.Ticks, req.HttpMethod,
req.OperationName, req.RemoteIp, req.RawUrl, req.UserAgent));
});
ResponseFilters.Add((req, resp, dto) => {
var log = LogManager.GetLogger(GetType());
log.Info(string.Format("RES {0}: {1} {2}", DateTimeOffset.Now.Ticks, resp.StatusCode,
resp.ContentType));
});
JsConfig.DateHandler = JsonDateHandler.ISO8601;
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] { new CredentialsAuthProvider() })
);
Plugins.Add(new RegistrationFeature());
Plugins.Add(new SessionFeature());
Plugins.Add(new RequestLogsFeature());
container.Register <IRedisClientsManager>(c =>
new PooledRedisClientManager(m_redisConnString));
container.Register <ICacheClient>(c =>
(ICacheClient)c.Resolve <IRedisClientsManager>()
.GetCacheClient())
.ReusedWithin(Funq.ReuseScope.None);
container.Register <IDbConnectionFactory>(
new OrmLiteConnectionFactory(m_pgConnString, PostgreSQLDialectProvider.Instance)
{
ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
});
//Use OrmLite DB Connection to persist the UserAuth and AuthProvider info
container.Register <IUserAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>()));
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(CreateQueueValidator).Assembly);
container.RegisterValidators(typeof(CreateTopicValidator).Assembly);
var config = new EndpointHostConfig();
if (m_debugEnabled)
{
config.DebugMode = true; //Show StackTraces in service responses during development
config.WriteErrorsToResponse = true;
config.ReturnsInnerException = true;
}
SetConfig(config);
CreateMissingTables(container);
}
public async Task <ActionResult> Search(RequestFilters filters)
{
var data = new
{
data = await _alertDashboardService.SearcAlerts(filters)
};
return(Json(data));
}
public override void Configure(Funq.Container container)
{
RequestFilters.Add((request, response, requestDTO) =>
{
if (!request.IsSecureConnection)
{
throw new Exception("The application needs to be secured. Use https instead of http for hosting!");
}
});
}
public static List <Article> TagsMatch(this List <Article> query, RequestFilters filters)
{
if (filters != null && filters.Tags != null)
{
if (filters.Tags.Count() > 0)
{
query = query.Where(a => a.Tags.Split('#', StringSplitOptions.None).AsQueryable().Intersect(filters.Tags).Any()).ToList();
}
}
return(query);
}
public override void Configure(Container container)
{
//containers
HttpServiceContainer.Build(container);
SearchContainer.Build(container);
// mappings
AllergyMapper.Build();
GoalsMapper.Build();
AllergyMedSearchMapper.Build();
MedSuppMapper.Build();
PatientNoteMapper.Build();
PatientSystemMapper.Build();
PatientContactMapper.Build();
ContactTypeLookUpsMappers.Build();
ContactMapper.Build();
Plugins.Add(new RequestLogsFeature()
{
RequiredRoles = new string[] {}
});
// request filtering for setting global vals.
RequestFilters.Add((req, res, requestDto) =>
{
HostContext.Instance.Items.Add("Contract", ((IAppDomainRequest)requestDto).ContractNumber);
HostContext.Instance.Items.Add("Version", ((IAppDomainRequest)requestDto).Version);
});
RequestFilters.Add((req, res, requestDto) =>
{
var obj = req.ResponseContentType;
});
var emitGlobalHeadersHandler = new CustomActionHandler((httpReq, httpRes) => httpRes.EndRequest());
SetConfig(new EndpointHostConfig
{
RawHttpHandlers =
{
(httpReq) => httpReq.HttpMethod == HttpMethods.Options ? emitGlobalHeadersHandler : null
},
GlobalResponseHeaders =
{
//{"Access-Control-Allow-Origin", "*"},
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
{ "Access-Control-Allow-Headers", "Content-Type" },
},
AllowJsonpRequests = true
});
// initialize datetime format
JsConfig.DateHandler = JsonDateHandler.ISO8601;
}
public override void Configure(Container container)
{
JsConfig.EmitCamelCaseNames = true;
Plugins.Add(new CorsFeature());
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
if (httpReq.HttpMethod == "OPTIONS")
{
httpRes.AddHeader("Access-Control-Allow-Methods", "POST, GET,DELETE, OPTIONS");
httpRes.AddHeader("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Accept, X-ApiKey");
httpRes.EndRequest();
}
});
}
public override void Configure(Funq.Container container)
{
Plugins.Add(new RequestLogsFeature()
{
RequiredRoles = new string[] {}
});
HttpServiceContainer.Build(container);
// request filtering for setting global vals.
RequestFilters.Add((req, res, requestDto) =>
{
HostContext.Instance.Items.Add("Contract", ((IDataDomainRequest)requestDto).ContractNumber.ToLower());
});
}
public override void Configure(Funq.Container container)
{
RequestBinders.Clear();
JsConfig.EmitCamelCaseNames = true;
JsConfig.IncludeNullValues = true;
JsConfig.DateHandler = JsonDateHandler.ISO8601;
Plugins.Add(new ValidationFeature());
// Add custom request filter
RequestFilters.Add(GetRequestProcessor.DeserializeJsonFromGet);
container.Adapter = new AutofacContainerAdapter(containerProvider);
container.RegisterValidators(typeof(GetTagRequestValidator).Assembly);
}
public override void Configure(Funq.Container container)
{
Plugins.Add(new RequestLogsFeature()
{
RequiredRoles = new string[] {}
});
// get path variables and make them accessible through the context.
RequestFilters.Add((req, res, requestDto) =>
{
HostContext.Instance.Items.Add("Contract", ((IDataDomainRequest)requestDto).ContractNumber.ToLower());
HostContext.Instance.Items.Add("UserId", ((IDataDomainRequest)requestDto).UserId);
});
HttpServiceContainer.Build(container);
}
public override void Configure(Container container)
{
RequestFilters.Add((req, resp, requestDto) => {
var log = LogManager.GetLogger(GetType());
log.Info(string.Format("REQ {0}: {1} {2} {3} {4} {5}", DateTimeOffset.Now.Ticks, req.HttpMethod,
req.OperationName, req.RemoteIp, req.RawUrl, req.UserAgent));
});
ResponseFilters.Add((req, resp, dto) => {
var log = LogManager.GetLogger(GetType());
log.Info(string.Format("RES {0}: {1} {2}", DateTimeOffset.Now.Ticks, resp.StatusCode,
resp.ContentType));
});
JsConfig.DateHandler = JsonDateHandler.ISO8601;
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] { new CredentialsAuthProvider() })
);
Plugins.Add(new RegistrationFeature());
Plugins.Add(new SessionFeature());
Plugins.Add(new RequestLogsFeature());
container.Register <ICacheClient> (new MemoryCacheClient());
container.Register <IDbConnectionFactory> (
new OrmLiteConnectionFactory(@"Data Source=db.sqlite;Version=3;",
SqliteOrmLiteDialectProvider.Instance)
{
ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
});
//Use OrmLite DB Connection to persist the UserAuth and AuthProvider info
container.Register <IUserAuthRepository> (c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory> ()));
Plugins.Add(new ValidationFeature());
var config = new EndpointHostConfig();
if (m_debugEnabled)
{
config.DebugMode = true; //Show StackTraces in service responses during development
config.WriteErrorsToResponse = true;
config.ReturnsInnerException = true;
}
SetConfig(config);
}
public override void Configure(Funq.Container container)
{
Config.DefaultRedirectPath = "/SimpleService";
//Register the quota plugin
Plugins.Add(new SimpleQuotaPlugin(
new SimpleQuotaProvider(),
new SimpleUsageStorer(UsageTimeToLive)
));
//Always return JSON
RequestFilters.Add((httpReq, httpResp, requestDto) => {
httpReq.ResponseContentType = ContentType.Json;
});
Config.DebugMode = true;
}
/// <summary>
/// Adds the rest handlers.
/// </summary>
/// <param name="services">The services.</param>
public void Init(IEnumerable <IService> services)
{
_restServices.AddRange(services);
ServiceController = CreateServiceController();
_logger.Info("Calling ServiceStack AppHost.Init");
ServiceController.Init(this);
var requestFilters = _appHost.GetExports <IRequestFilter>().ToList();
foreach (var filter in requestFilters)
{
RequestFilters.Add(filter.Filter);
}
ResponseFilters.Add(new ResponseFilter(_logger).FilterResponse);
}
public override void Configure(Container container)
{
var appHostConfiger = new AppHostConfiger(this, container);
appHostConfiger.ConfigGlobleProperty();
appHostConfiger.ConfigureIoc();
appHostConfiger.ConfigPlugins();
this.CustomizeConfigure(container);
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
if (httpReq.HttpMethod == "OPTIONS")
{
httpRes.AddHeader("Access-Control-Allow-Origin", "*");
httpRes.AddHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
httpRes.AddHeader("Access-Control-Allow-Headers", "X-Requested-With, Content-Type");
httpRes.End();
}
});
}
public static List <Article> RatingFilter(this List <Article> query, RequestFilters filters)
{
if (filters != null)
{
foreach (var filter in filters.Filters)
{
if (filter.Path == "rating")
{
if (filter.Action == FiltersCompareActions.GreaterThenOrEqual)
{
query = query.Where(a => a.Rating >= int.Parse(filter.Value)).ToList();
}
else
{
query = query.Where(a => a.Rating >= int.Parse(filter.Value)).ToList();
}
}
}
}
return(query);
}
/// <summary>
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// </summary>
public override void Configure(Container container)
{
//Config examples
//this.Plugins.Add(new PostmanFeature());
this.Plugins.Add(new CorsFeature());
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
if (httpReq.HttpMethod == "OPTIONS")
{
httpRes.AddHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
httpRes.AddHeader("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Accept, X-ApiKey");
httpRes.EndRequest();
}
});
//container.Register<>();
container.Register <IUserRepo>(new UserRepo(new DatabaseMapper()));
container.Register <IUserBll>(new UserBll(new UserRepo(new DatabaseMapper())));
container.Register <ICategoryDal>(new CategoryDal(new DatabaseMapper()));
container.Register <ICategoryBll>(new CategoryBll(new CategoryDal(new DatabaseMapper())));
container.Register <ITaskDal>(new TaskDal(new DatabaseMapper()));
container.Register <ITaskBll>(new TaskBll(new TaskDal(new DatabaseMapper())));
}
public HttpResponseMessage GetSearchResults(RequestFilters requestFilters)
{
try
{
searchViewModel = new SearchViewModel();
searchSerObj = new SearchService();
RequestFilters reqFiltersObj = new RequestFilters();
reqFiltersObj = requestFilters;
//RequestFilters reqFiltersObj = new JavaScriptSerializer().Deserialize<List<RequestFilters>>(selectedFilters).FirstOrDefault();
//RequestFilters reqFiltersObj = new RequestFilters();
reqFiltersObj.SelectedCountry = reqFiltersObj.SelectedCountry.Equals(Constants.TEXT_DROPDOWN_DEFAULT) ? "0" : reqFiltersObj.SelectedCountry;
reqFiltersObj.SelectedArea = reqFiltersObj.SelectedArea.Equals(Constants.TEXT_DROPDOWN_DEFAULT) || reqFiltersObj.SelectedArea.Equals(string.Empty) ? "0" : reqFiltersObj.SelectedArea;
reqFiltersObj.SelectedLeadAI = reqFiltersObj.SelectedLeadAI.Equals(Constants.TEXT_DROPDOWN_DEFAULT) ? "0" : reqFiltersObj.SelectedLeadAI;
reqFiltersObj.SelectedOrginator = reqFiltersObj.SelectedOrginator == null ? Constants.TEXT_DROPDOWN_DEFAULT : reqFiltersObj.SelectedOrginator;
reqFiltersObj.SelectedReqType = reqFiltersObj.SelectedReqType.Equals(Constants.TEXT_DROPDOWN_DEFAULT) ? "0" : reqFiltersObj.SelectedReqType;
reqFiltersObj.SelectedStatus = reqFiltersObj.SelectedStatus.Equals(Constants.TEXT_DROPDOWN_DEFAULT) ? "0" : reqFiltersObj.SelectedStatus;
reqFiltersObj.SelectedSubArea = string.Empty;
reqFiltersObj.SelectedSubStatus = reqFiltersObj.SelectedSubStatus.Equals(Constants.TEXT_DROPDOWN_DEFAULT) ? "0" : reqFiltersObj.SelectedSubStatus;
reqFiltersObj.SUorPU = reqFiltersObj.SUorPU.Equals(string.Empty) ? "-1" : reqFiltersObj.SUorPU;
reqFiltersObj.NSU = reqFiltersObj.NSU.Equals(string.Empty) ? "-1" : reqFiltersObj.NSU;
reqFiltersObj.Concerns = reqFiltersObj.Concerns;
reqFiltersObj.ReqNumber = reqFiltersObj.ReqNumber.Equals(string.Empty) ? "-1" : reqFiltersObj.ReqNumber;
searchViewModel.RequestResults = searchSerObj.GetSearchResultsData(reqFiltersObj);
return(Request.CreateResponse(HttpStatusCode.OK, searchViewModel));
}
catch (Exception ex)
{
NameValueCollection additionalInfo = new NameValueCollection();
additionalInfo.Add("PageName", "Search");
ExceptionManager.Publish(ex, additionalInfo);
//Message = errMessages.GetString(Constants.Err_PageLoad);
errEntity.ErrorNumber = 420;
errEntity.ErrorMess = "Error in GetSearchResults method of search controller";
searchViewModel.ErrorBE = errEntity;
return(Request.CreateResponse(HttpStatusCode.OK, searchViewModel));
}
}
public override void Configure(Funq.Container container)
{
Plugins.Add(new RequestLogsFeature()
{
RequiredRoles = new string[] {}
});
Plugins.Add(new SwaggerFeature());
// get path variables and make them accessible through the context.
RequestFilters.Add((req, res, requestDto) =>
{
//{ServiceStack.Api.Swagger.Resources}
if (requestDto.GetType() == typeof(Resources) || requestDto.GetType() == typeof(ResourceRequest))
{
return;
}
HostContext.Instance.Items.Add("Contract", ((IDataDomainRequest)requestDto).ContractNumber.ToLower());
HostContext.Instance.Items.Add("UserId", ((IDataDomainRequest)requestDto).UserId);
});
HttpServiceContainer.Build(container);
}
public override void Configure(Container container)
{
// I add some request/response filters to set up the correct database
// connection for the integration test database
RequestFilters.Add((httpRequest, httpResponse, requestDto) =>
{
var dbContext = MakeSomeDatabaseContext();
httpRequest.Items["DatabaseIntegrationTestContext"] = dbContext;
});
ResponseFilters.Add((httpRequest, httpResponse, responseDto) =>
{
var dbContext = httpRequest.Items["DatabaseIntegrationTestContext"] as DbContext;
if (dbContext != null)
{
dbContext.Dispose();
httpRequest.Items.Remove("DatabaseIntegrationTestContext");
}
});
// now include any configuration you want to share between this
// and your regular AppHost, e.g. IoC setup, EndpointHostConfig,
// JsConfig setup, adding Plugins, etc.
SharedAppHost.Configure(container);
}
private static AlertResponse ProcessAlertsWithFilters(AlertResponse currentAlerts,
RequestFilters filters)
{
if (filters.EventType.HasValue)
{
if (filters.EventType == EventType.Event)
{
currentAlerts.Ranges = new List <AlertRange>();
}
if (filters.EventType == EventType.Range)
{
currentAlerts.Events = new List <AlertEvent>();
}
}
if (filters.AlertTypeId.HasValue)
{
currentAlerts.Events = currentAlerts.Events.Where(x => x.Alert_Type_Id == filters.AlertTypeId);
currentAlerts.Ranges = currentAlerts.Ranges.Where(x => x.Alert_Type_Id == filters.AlertTypeId);
}
if (filters.CapturedPCId.HasValue)
{
currentAlerts.Events = currentAlerts.Events.Where(x => x.Capture_PC_Id == filters.CapturedPCId);
currentAlerts.Ranges = currentAlerts.Ranges.Where(x => x.Capture_PC_Id == filters.CapturedPCId);
}
if (filters.RecordingId.HasValue)
{
currentAlerts.Events = currentAlerts.Events.Where(x => x.Recording_Id == filters.RecordingId);
currentAlerts.Ranges = currentAlerts.Ranges.Where(x => x.Recording_Id == filters.RecordingId);
}
return(currentAlerts);
}
public PagedRequest()
{
RequestFilters = new RequestFilters();
}
/*
* // not needed anymore, we do the type resolution ourselves now.
*
* private static readonly string[] _hideKnownAssemblies = new[] {
* "ServiceStack", // exclude the service stack assembly
* "ClrPlus",
* "b03f5f7f11d50a3a", // Microsoft
* "b77a5c561934e089", // Microsoft
* "31bf3856ad364e35" // Microsoft
* };
*
* private static IEnumerable<Assembly> GetActiveAssemblies() {
* return AppDomain.CurrentDomain.GetAssemblies().Where(each => !_hideKnownAssemblies.Any(x => each.FullName.IndexOf(x) > -1));
* }
*/
public override void Configure(Container container)
{
_configured = true;
// Feature disableFeatures = Feature.Jsv | Feature.Soap;
SetConfig(new EndpointHostConfig {
// EnableFeatures = Feature.All.Remove(disableFeatures), //all formats except of JSV and SOAP
DebugMode = true, //Show StackTraces in service responses during development
WriteErrorsToResponse = false, //Disable exception handling
DefaultContentType = ContentType.Json, //Change default content type
AllowJsonpRequests = true, //Enable JSONP requests
ServiceName = "RestService",
});
#if DEBUG
LogManager.LogFactory = new DebugLogFactory();
#endif
using (var ps = RunspacePool.Dynamic()) {
foreach (var restCommand in _activeCommands)
{
PSObject command = ps.LookupCommand(restCommand.Name);
if (command != null)
{
var cmdletInfo = (command.ImmediateBaseObject as CmdletInfo);
if (cmdletInfo != null)
{
dynamic d = new AccessPrivateWrapper((ServiceController as ServiceController));
// for each type we're adding, see if it's already been added already.
if (!d.requestExecMap.ContainsKey(cmdletInfo.ImplementingType))
{
(ServiceController as ServiceController).RegisterGService(GetTypeFactory(cmdletInfo.ImplementingType), cmdletInfo.ImplementingType);
(ServiceController as ServiceController).RegisterNService(GetTypeFactory(cmdletInfo.ImplementingType), cmdletInfo.ImplementingType);
}
ReverseLookup.AddOrSet(cmdletInfo.ImplementingType, restCommand);
Routes.Add(cmdletInfo.ImplementingType, "/" + restCommand.PublishAs + "/", "GET");
}
else
{
throw new ClrPlusException("command isn't cmdletinfo: {0}".format(command.GetType()));
}
}
}
}
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] {
new CustomBasicAuthProvider(),
// new CustomCredentialsAuthProvider(),
}
));
// stick a request filter in to validate that the user has the right to actually
// call this method.
RequestFilters.Add((request, response, requestDto) => {
var restCommand = ReverseLookup[requestDto.GetType()];
// is this one of the restCommands?
// and does it has roles defined?
if (restCommand != null && !restCommand.Roles.IsNullOrEmpty())
{
// ensure we're authenticated if the user passed the right stuff in the request
try {
AuthenticateAttribute.AuthenticateIfBasicAuth(request, response);
} catch (Exception e) {
Console.WriteLine(e.Message);
response.StatusCode = 401;
response.AddHeader("WWW-Authenticate", "Basic realm=\"rest-service\"");
response.StatusDescription = "Unauthorized";
response.EndServiceStackRequest(false);
return;
}
// get the session object.
var session = request.GetSession(false);
// check if we got our authentication.
if (!session.IsAuthenticated)
{
response.StatusCode = 401;
response.AddHeader("WWW-Authenticate", "Basic realm=\"rest-service\"");
response.StatusDescription = "Unauthorized";
response.EndServiceStackRequest(false);
return;
}
// validate the user has the role.
if (!restCommand.Roles.Any(session.HasRole))
{
response.StatusCode = 403;
response.StatusDescription = "Forbidden";
response.EndServiceStackRequest(false);
}
var req = (requestDto as IHasSession);
if (req != null)
{
req.Session = session;
}
}
});
}
public RequestViewModel(User user, Request request, IEnumerable<Vlan> vlans, IEnumerable<Switch> switches,
IEnumerable<SwitchModule> switchModules, IEnumerable<SwitchPort> switchPorts, RequestFilters requestFilter)
{
RequestFilter = requestFilter;
User = user;
Switches = switches;
SwitchModules = switchModules;
SwitchPorts = switchPorts;
var repo = new RequestRepository();
OlderRequest = repo.GetOlderRequest(request);
NewerRequest = repo.GetNewerRequest(request);
Request = new RequestFormViewModel(request, user, RequestFormViews.View);
var lastApprovedAction = repo.GetLastApprovedSecurityAction(request);
if (lastApprovedAction != null)
{
Vlan = lastApprovedAction.Vlan;
}
// Get the last security action of this request version.
if (request.SecurityActions.Count > 0)
{
LastSecurityAction = request.SecurityActions.OrderByDescending(x => x.Id).First();
}
// Get the last communication action of this request version.
if (request.CommunicationActions.Count > 0)
{
LastCommunicationAction = request.CommunicationActions.OrderByDescending(x => x.Id).First();
Notes = LastCommunicationAction.Notes;
}
var lastCompletedAction = repo.GetLastCompletedCommunicationAction(request);
if (lastCompletedAction != null)
{
IPAddress = CommonFunctions.IPDotted(lastCompletedAction.ServerIP.IP.Address);
if (lastCompletedAction.Completed == true)
{
if (Request.ServerType.Id == (int)ServerTypes.Standalone)
{
SwitchIPAddress = CommonFunctions.IPDotted(lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Switch.IP.Address);
SwitchName = lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Switch.Name;
SwitchNumber = lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Switch.StackableNumber;
SwitchModuleNumber = lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Number;
SwitchPortNumber = lastCompletedAction.ServerIP.SwitchPort.Port;
}
}
}
Vlans = vlans;
Logs = new List<Log>();
var reqs = repo.GetRequestUpdates(request.OriginalRequest).ToList();
Logs.AddRange(reqs.Select(x => new Log
{
User = x.User,
Date = x.SubmissionDate,
Notes = x.Notes,
LogAction = (x.Id == x.OriginalId) ? LogActions.RequestCreated : LogActions.RequestUpdated
}));
Logs.AddRange(reqs.SelectMany(x => x.SecurityActions.Select(action => new Log
{
User = action.User,
Date = action.Date,
Notes = action.Notes,
LogAction = action.Approved == true ? LogActions.SecurityApproved :
(action.Approved == false ? LogActions.SecurityRejected :
(action.Assigned ? LogActions.SecurityAssigned :
LogActions.SecurityReleased))
})));
Logs.AddRange(reqs.SelectMany(x => x.CommunicationActions.Select(action => new Log
{
User = action.User,
Date = action.Date,
Notes = action.Notes,
LogAction = action.Completed == true ? LogActions.CommunicationCompleted :
(action.Completed == false ? LogActions.CommunicationProcessing :
(action.Assigned ? LogActions.CommunicationAssigned :
LogActions.CommunicationReleased))
})));
Logs = Logs.OrderByDescending(x => x.Date).ToList();
}
public IRequestFilter Remove(string name)
{
RequestFilters.TryRemove(name, out IRequestFilter item);
return(item);
}
public override void Configure(Container container)
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.Enrich.FromLogContext()
.CreateLogger();
JsConfig.EmitCamelCaseNames = true;
container.Register <ICaseRepository>(new CaseRepository());
container.Register <IUserRepository>(new UserRepository());
container.Register <IUserRoleRepository>(new UserRoleRepository());
container.Register <ITokenRepository>(new TokenRepository());
container.Register <IRoleRepository>(new RoleRepository());
container.Register <ICaseInformationRepository>(new CaseInformationRepository());
container.Register <ICaseReferenceRepository>(new CaseReferenceRepository());
container.Register <ICaseStatusRepository>(new CaseStatusRepository());
container.Register <IClientRepository>(new ClientRepository());
container.Register <INotesRepository>(new NotesRepository());
container.Register <IDeclarationDal>(c =>
new DeclarationDal(
c.Resolve <IDatabaseMapper>()
)
);
container.Register <IMasterDataRepository>(c =>
new MasterDataRepository(
c.Resolve <IMasterDataMapper>()
)
);
container.Register <IClientMapper>(new ClientMapper());
container.Register <ICaseInformationMapper>(new CaseInformationMapper());
container.Register <ICaseStatusMapper>(new CaseStatusMapper());
container.Register <ICaseReferenceMapper>(new CaseReferenceMapper());
container.Register <INotesMapper>(new NotesMapper());
container.Register <IDatabaseMapper>(new DatabaseMapper());
container.Register <IMasterDataMapper>(new MasterDataMapper());
container.Register <IRoleBusinessLogic>(c =>
new RoleBusinessLogic(
c.Resolve <IUserRoleRepository>(),
c.Resolve <IRoleRepository>()
)
);
container.Register <ITokenBusinessLogic>(c =>
new TokenBusinessLogic(
c.Resolve <IRoleBusinessLogic>(),
c.Resolve <ITokenRepository>(),
c.Resolve <IUserRepository>()
)
);
container.Register <IUserBusinessLogic>(c =>
new UserBusinessLogic(
c.Resolve <IUserRepository>(),
c.Resolve <ITokenBusinessLogic>()
)
);
container.Register <IClientBusinessLogic>(c =>
new ClientBusinessLogic(
c.Resolve <IClientRepository>(),
c.Resolve <IClientMapper>()
)
);
container.Register <ICaseInformationBusinessLogic>(c =>
new CaseInformationBusinessLogic(
c.Resolve <ICaseInformationRepository>(),
c.Resolve <ICaseInformationMapper>()
)
);
container.Register <ICaseStatusBusinessLogic>(c =>
new CaseStatusBusinessLogic(
c.Resolve <ICaseStatusRepository>(),
c.Resolve <ICaseStatusMapper>()
)
);
container.Register <INotesBusinessLogic>(c =>
new NotesBusinessLogic(
c.Resolve <INotesRepository>(),
c.Resolve <INotesMapper>()
)
);
container.Register <ICaseReferenceBusinessLogic>(c =>
new CaseReferenceBusinessLogic(
c.Resolve <ICaseReferenceRepository>(),
c.Resolve <ICaseReferenceMapper>()
)
);
container.Register <ICaseBusinessLogic>(c =>
new CaseBusinessLogic(
c.Resolve <IClientBusinessLogic>(),
c.Resolve <ICaseInformationBusinessLogic>(),
c.Resolve <ICaseStatusBusinessLogic>(),
c.Resolve <INotesBusinessLogic>(),
c.Resolve <ICaseReferenceBusinessLogic>(),
c.Resolve <ICaseRepository>()
)
);
container.Register <IDeclarationBll>(c =>
new DeclarationBll(
c.Resolve <IDeclarationDal>()
)
);
container.Register <IMasterDataBll>(c =>
new MasterDataBll(
c.Resolve <IMasterDataRepository>()
)
);
Plugins.Add(new CorsFeature());
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
if (httpReq.HttpMethod == "OPTIONS")
{
httpRes.AddHeader("Access-Control-Allow-Methods", "POST, GET,DELETE, OPTIONS");
httpRes.AddHeader("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Accept, X-ApiKey");
httpRes.EndRequest();
}
});
}
