public override IEnumerable<WarningOccurrenceDto> Analyze(ISqlRepository sqlRepository, UrlDto urlDto) { var warningOccurrencesList = new List<WarningOccurrenceDto>(); if (urlDto.Status != HttpStatusCode.OK) { return warningOccurrencesList; } foreach (var link in sqlRepository.GetWebPageLinks(urlDto.UrlId.Value)) { if (link.Status == HttpStatusCode.NotFound) { IWarning warning = GetWarning(typeof(BrokenLinkWarning)); warningOccurrencesList.Add(new WarningOccurrenceDto() { UrlId = (long)urlDto.UrlId, Message = String.Format(warning.Description, link.Url), WarningType = warning } ); } } return warningOccurrencesList; }
public SqlUserStore(string connectionStringName) { _connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString; _repository = new SqlRepository(connectionStringName); _roleStote = new SqlRoleStore <IdentityRole>(_repository); }
public Enum(DalConfig config, ISqlRepository sqlRepository) { _config = config; if (sqlRepository == null) throw new ArgumentNullException(nameof(sqlRepository)); _sqlRepository = sqlRepository; }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "post", Route = "customer")] HttpRequest req, ILogger log) { log.LogInformation("C# HTTP trigger SQLPost function processed a request."); try { string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); log.LogInformation($"request body:{requestBody}"); var cust = JsonConvert.DeserializeObject <Customer>(requestBody); ISqlRepository <Customer> repo = _serviceProvider.GetService(typeof(ISqlRepository <Customer>)) as ISqlRepository <Customer>; if (string.IsNullOrEmpty(cust.id)) { cust.id = Guid.NewGuid().ToString(); } var result = await repo.Insert(cust); string jsonResult = JsonConvert.SerializeObject(result); return((ActionResult) new OkObjectResult(jsonResult)); } catch (Exception ex) { log.LogError(ex, "Function SQL Post Failed!"); return((ActionResult) new BadRequestResult()); } }
public ArticleService(ISqlRepository <Article> articleEfRepository, IElasticRepository <ArticleDto> articleEsRepository, IMapper mapper) { _articleSqlRepository = articleEfRepository; _articleElasticRepository = articleEsRepository; _mapper = mapper; }
public BlogManager(IBlogRepository Blogs, ISqlRepository sql, ITenantManager tenantManager, IHttpContextAccessor accessor) { _Blogs = Blogs; _sql = sql; _tenantManager = tenantManager; _accessor = accessor; }
public GroupMemberService( ISqlRepository <GroupMember> groupMemberRepository, ICacheableIntranetMemberService memberCacheService) : base(groupMemberRepository) { _groupMemberRepository = groupMemberRepository; _memberCacheService = memberCacheService; }
public MainWindowViewModel(IJsonRepository jsonRepository, ISqlRepository sqlRepository, IModbusMaster modbusMaster) { _jsonRepository = jsonRepository ?? throw new ArgumentNullException(nameof(jsonRepository)); _sqlRepository = sqlRepository ?? throw new ArgumentNullException(nameof(sqlRepository)); _modbusMaster = modbusMaster ?? throw new ArgumentNullException(nameof(modbusMaster)); StartMethod(); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", Route = "customer/{uniqueid}")] HttpRequest req, string uniqueid, ILogger log) { log.LogInformation($"C# HTTP trigger function processed a request, uniqueid={uniqueid}"); try { ISqlRepository <Customer> repo = _serviceProvider.GetService(typeof(ISqlRepository <Customer>)) as ISqlRepository <Customer>; Expression <Func <Customer, bool> > lambda = x => x.UniqueId == uniqueid; var result = await repo.Get(lambda); var jsonResult = JsonConvert.SerializeObject(result); log.LogInformation($"result: {jsonResult}"); return((ActionResult) new OkObjectResult(jsonResult)); } catch (Exception e) { log.LogError(e, $"Sql API failed to get={uniqueid}"); return((ActionResult) new BadRequestResult()); } }
public MembershipService(ICryptoService cryptoService, ISqlRepository <User> userRepository, ISqlRepository <Role> roleRepository, ISqlRepository <UserInRole> userRoleRepository) { _cryptoService = cryptoService; _userRepository = userRepository; _roleRepository = roleRepository; _userInRoleRepository = userRoleRepository; }
public NotificationSettingsService( ISqlRepository <NotificationSetting> repository, IBackofficeNotificationSettingsProvider backofficeNotificationSettingsProvider) { _repository = repository; _backofficeNotificationSettingsProvider = backofficeNotificationSettingsProvider; }
public static IEnumerable <Role> GetUserRoles(this ISqlRepository <UserInRole> userRoleRepository, ISqlRepository <Role> roleRepository, Guid userId) { IEnumerable <Role> roles = Enumerable.Empty <Role>(); if (userId != null) { userRoleRepository.SetCommandTimeout(3000); var pg = new PredicateGroup { Operator = GroupOperator.And, Predicates = new List <IPredicate>() }; pg.Predicates.Add(Predicates.Field <UserInRole>(u => u.UserId, Operator.Eq, userId)); pg.Predicates.Add(Predicates.Field <UserInRole>(u => u.Status, Operator.Eq, (int)Status.Yes)); var userInRole = userRoleRepository.GetList(pg); if (userInRole.IsNotEmpty()) { var userRoleKeys = userInRole.Select(x => x.Id).ToArray(); pg.Predicates.Clear(); pg.Predicates.Add(Predicates.Field <Role>(u => u.Id, Operator.Eq, userRoleKeys)); pg.Predicates.Add(Predicates.Field <Role>(u => u.Status, Operator.Eq, (int)Status.Yes)); roles = roleRepository.GetList(pg); } } return(roles); }
public TableValuedParameter(DalConfig config, ISqlRepository sqlRepository) { _config = config; if (sqlRepository == null) throw new ArgumentNullException(nameof(sqlRepository)); _sqlRepository = sqlRepository; }
public SQLController(IMapper mapper, ILogger <MESController> logger, ISqlRepository sqlRepository, EF6sqlserver23 eF6Sqlserver23) { _logger = logger; _sqlRepository = sqlRepository ?? throw new ArgumentNullException(nameof(sqlRepository)); _eF6Sqlserver23 = eF6Sqlserver23 ?? throw new ArgumentNullException(nameof(eF6Sqlserver23)); _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); }
public HtmlTextManager(IHtmlTextRepository htmlText, ITenantManager tenantManager, IHttpContextAccessor httpContextAccessor, ISqlRepository sqlRepository) { _htmlText = htmlText; _tenantManager = tenantManager; _accessor = httpContextAccessor; _sqlRepository = sqlRepository; }
public override IEnumerable<WarningOccurrenceDto> Analyze(ISqlRepository sqlRepository, UrlDto urlDto) { var warningOccurrencesList = new List<WarningOccurrenceDto>(); if (urlDto.Contents == null) { _log.Debug("urlDto is empty for url:" + urlDto.Url); return warningOccurrencesList; } if (urlDto.Status != HttpStatusCode.OK) { return warningOccurrencesList; } var title = urlDto.Contents.SingleOrDefault(element => element.ContentType == ContentTypesEnum.Title); _log.Debug(String.Format("Analyze title '{0}' for url '{1}'", (title == null || title.Element == null) ? "" : title.Element, urlDto.Url)); if (title == null || String.IsNullOrEmpty(title.Element)) { IWarning warning = GetWarning(typeof(EmptyTitleWarning)); warningOccurrencesList.Add(new WarningOccurrenceDto() { UrlId = (long) urlDto.UrlId, Message = warning.Description, WarningType = warning } ); } else { var elements = sqlRepository.GetContentForElementText(ContentTypesEnum.Title, title.Element); if (elements.Any()) { ContentDto targetContentDto = elements.FirstOrDefault(x => x.UrlId != urlDto.UrlId); if (targetContentDto != null) { UrlDto targetUrlDto; sqlRepository.FindUrl(targetContentDto.UrlId, out targetUrlDto); IWarning warning = GetWarning(typeof(DuplicatedTitleWarning)); warningOccurrencesList.Add(new WarningOccurrenceDto() { UrlId = (long)urlDto.UrlId, Message = String.Format(warning.Description, title.Element, targetUrlDto.Url), WarningType = warning } ); } } } return warningOccurrencesList; }
public HomeController(ISqlRepository sqlRepository, ITaxCalculation taxCalculation, IPublisher publisher) { _sqlRepository = sqlRepository; _taxCalculation = taxCalculation; _publisher = publisher; }
public Procedure(DalConfig config, ISqlRepository sqlRepository, bool supportsAsync) { _config = config; if (sqlRepository == null) throw new ArgumentNullException(nameof(sqlRepository)); _sqlRepository = sqlRepository; _supportsAsync = supportsAsync; }
public static ISqlRepository <TEntity> SetCommandTimeout <TEntity>(this ISqlRepository <TEntity> sqlRepository, int timeout) where TEntity : EntityBase, new() { if (timeout >= 0) { sqlRepository.Dbsession.CommandTimeout = timeout; } return(sqlRepository); }
public void ProcessPage(ISqlRepository sqlRepository, UrlDto urlDto, Report report) { foreach (var rule in _rules) { var warningOccurrences = rule.Analyze(sqlRepository, urlDto); report.WarningOccurrences.AddRange(warningOccurrences); } }
public LinkPreviewController( ILinkPreviewClient linkPreviewClient, ILinkPreviewConfigProvider configProvider, ISqlRepository <int, LinkPreviewEntity> previewRepository, LinkPreviewModelMapper linkPreviewModelMapper) : base(linkPreviewClient, configProvider, previewRepository, linkPreviewModelMapper) { }
public static ISqlRepository CreateOrGet() { if (_sqlRepository == null) { _sqlRepository = new SqlRepository(); } return(_sqlRepository); }
public MessageToSqlController(ISqlRepository repository, IRabbitRepository eventPublisher, ILogger <MessageToSqlController> logger) { _repository = repository; _eventPublisher = eventPublisher; _logger = logger; }
public PaymentService(ISqlRepository <Article> articleSqlRepository, ISqlRepository <DomainPayment> paymentSqlRepository, ISqlRepository <User> userRepository, IPayPalClient paypalClient) { _articleSqlRepository = articleSqlRepository; _userSqlRepository = userRepository; _paymentSqlRepository = paymentSqlRepository; _paypalClient = paypalClient; }
public GroupDocumentsService( ISqlRepository <GroupDocument> repository, IGroupMemberService groupMemberService, IIntranetMemberService <IntranetMember> intranetMemberService) { _repository = repository; _groupMemberService = groupMemberService; _intranetMemberService = intranetMemberService; }
public NbaService(IHttpService httpSvc, ISqlRepository sqlSvc, IConfigService cfgSvc, ILogService logSvc, IDataRepository <vNbaGame> repo) { _httpSvc = httpSvc; _sqlRepo = sqlSvc; cfgSvc.AppId = 0; _cfgSvc = cfgSvc; _logSvc = logSvc; _repo = repo; }
public CommentLinkPreviewService( ISqlRepository <int, CommentToLinkPreviewEntity> previewRelationRepository, ISqlRepository <int, LinkPreviewEntity> previewRepository, LinkPreviewModelMapper linkPreviewModelMapper) { _previewRelationRepository = previewRelationRepository; _previewRepository = previewRepository; _linkPreviewModelMapper = linkPreviewModelMapper; }
public SampleDataService( ISqlRepository sqlRepository, IMediaService mediaService, IStaticCacheManager cache) { _sqlRepository = sqlRepository; _mediaService = mediaService; _cache = cache; }
public StateOrProvinceService( ISqlRepository sqlRepository, IStaticCacheManager cache, IRepository <StateOrProvince> provinceRepository) { _sqlRepository = sqlRepository; _cache = cache; _provinceRepository = provinceRepository; }
public IdentityService(ISqlRepository <User> userRepository, IPasswordHasher <User> passwordHasher, IJwtHandler jwtHandler, ISqlRepository <RefreshToken> refreshTokenRepository, IClaimsProvider claimsProvider) { _userRepository = userRepository; _passwordHasher = passwordHasher; _jwtHandler = jwtHandler; _refreshTokenRepository = refreshTokenRepository; _claimsProvider = claimsProvider; }
public GroupService( ISqlRepository <Group> groupRepository, ICacheService memoryCacheService, IPermissionsService permissionsService) { _groupRepository = groupRepository; _memoryCacheService = memoryCacheService; _permissionsService = permissionsService; }
public ActivityLinkPreviewService( ISqlRepository <int, ActivityToLinkPreviewEntity> previewRelationRepository, ISqlRepository <int, LinkPreviewEntity> previewRepository, LinkPreviewModelMapper linkPreviewModelMapper) { _previewRelationRepository = previewRelationRepository; _previewRepository = previewRepository; _linkPreviewModelMapper = linkPreviewModelMapper; }
public void UpgradeSqlServer(ISqlRepository sql, string connectionString, string databaseType, bool isMaster) { var script = (isMaster) ? "MigrateMaster.sql" : "MigrateTenant.sql"; var query = sql.GetScriptFromAssembly(Assembly.GetExecutingAssembly(), script); query = query.Replace("{{Version}}", Constants.Version); sql.ExecuteNonQuery(connectionString, databaseType, query); }
public CommentsService(ICommentLinkPreviewService commentLinkPreviewService, ISqlRepository<Guid, Comment> commentsRepository, IGroupActivityService groupActivityService, IGroupService groupService) { _commentLinkPreviewService = commentLinkPreviewService; _commentsRepository = commentsRepository; _groupActivityService = groupActivityService; _groupService = groupService; }
public GroupService( ISqlRepository <Group> groupRepository, ICacheService memoryCacheService, IPermissionsService permissionsService, IIntranetMemberService <IIntranetMember> intranetMemberService) { _groupRepository = groupRepository; _memoryCacheService = memoryCacheService; _permissionsService = permissionsService; _intranetMemberService = intranetMemberService; }
public ModuleDefinitionController(IModuleDefinitionRepository moduleDefinitions, IModuleRepository modules, IUserPermissions userPermissions, IInstallationManager installationManager, IWebHostEnvironment environment, ITenantResolver resolver, ISqlRepository sql, ILogManager logger) { _moduleDefinitions = moduleDefinitions; _modules = modules; _userPermissions = userPermissions; _installationManager = installationManager; _environment = environment; _resolver = resolver; _sql = sql; _logger = logger; }
protected override void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { // TODO: dispose managed state (managed objects). CurrentUser = null; } // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. repository.Dispose(); // TODO: set large fields to null. repository = null; disposedValue = true; } base.Dispose(disposing); }
static UrlDto InsertUrlDtoWithOneStatusCodeOKLink(ISqlRepository repository, HttpStatusCode httpStatusCode) { var urlDtoLink = new UrlDto { Status = httpStatusCode }; repository.InsertOrUpdateUrl(urlDtoLink); var urlDto = new UrlDto { Status = HttpStatusCode.OK, Links = new List<LinkDto>() { new LinkDto() { TargetUrlId = (long) urlDtoLink.UrlId, } }.ToArray() }; return repository.InsertOrUpdateUrl(urlDto); }
public AccountBLL(ISqlRepository sqlRepository) { this.SqlRepository = sqlRepository; }
public SampleDataController(ISqlRepository sqlRepository) { this.sqlRepository = sqlRepository; }
/// <summary> /// Construct DI Repository /// </summary> /// <param name="repo"></param> public MyPageController(ISqlRepository repo) { _repository = repo; }
public abstract IEnumerable<WarningOccurrenceDto> Analyze(ISqlRepository sqlRepository, UrlDto urlDto);
public MonitoringEventsService(ISqlRepository<MonitoringEvents> repo, ILogger logger) { Repo = repo; Logger = logger; }
public ApplicationController(ISqlRepository _repository) { repository = _repository; }
public Sql2Excel(ISqlRepository sqlRepository) { _sqlRepository = sqlRepository; _results = new Dictionary<Query, DataTable>(); Queries = new List<Query>(); }
internal Analisys(ISqlRepository sqlRepository) { _sqlRepository = sqlRepository; }