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;
}
