private FindByUserDatabase(IRepositoryContext context, DbProviderFactory providerFactory, string connectionString)
{
Context = context;
ProviderFactory = providerFactory;
ConnectionString = connectionString;
Connection = GetConnection();
}
public MetricExportDefinition(IRepositoryContext context, ExportAddInConfiguration config)
{
_context = context;
Config = config;
Applications = new HashSet<string>();
Metrics = new HashSet<string>();
}
public void Export(IRepositoryContext context, ISession session)
{
if (!Config.EnableLogMessageExport)
return;
try
{
using (var writer = StreamCreator.CreateLogStream(context, Config, session))
{
Writer = writer;
ExportSummary(context, session);
foreach (var message in session.GetMessages())
{
if (message.Severity > Config.MinimumSeverity)
continue;
ExportLogMessage(context, session, message);
}
}
}
catch (Exception ex)
{
context.Log.RecordException(ex, LogCategory, true);
}
}
public RelatedSongsQuery(IRepositoryContext<Song> ctx) {
ParamIs.NotNull(() => ctx);
this.ctx = ctx;
}
public void CheckComment(Comment comment, IEntryLinkFactory entryLinkFactory, IRepositoryContext<User> ctx) {
var userMatches = Regex.Match(comment.Message, @"@(\w+)");
if (!userMatches.Success)
return;
var userNames = userMatches.Groups.Cast<Group>().Skip(1).Select(g => g.Value).ToArray();
var users = ctx.Query().Where(u => u.Active && userNames.Contains(u.Name)).ToArray();
if (!users.Any())
return;
var commentMsg = comment.Message.Truncate(200);
var msg = string.Format("{0} mentioned you in a comment for {1}\n\n{2}", comment.AuthorName, MarkdownHelper.CreateMarkdownLink(entryLinkFactory.GetFullEntryUrl(comment.Entry), comment.Entry.DefaultName), commentMsg);
foreach (var user in users) {
var notification = new UserMessage(user, "Mentioned in a comment", msg, false);
ctx.OfType<UserMessage>().Save(notification);
}
}
protected override void ExportLogMessage(IRepositoryContext context, ISession session, ILogMessage message)
{
WriteLine();
if (message.Severity == LogMessageSeverity.Verbose)
Write("{0} {1}\r\n", message.Timestamp, message.Caption.Trim());
else
{
var severity = message.Severity.ToString();
if (severity.StartsWith("Info") || severity.StartsWith("Warn"))
severity = severity.Substring(0, 4);
else
severity = severity.ToUpperInvariant();
Write("{0} {2} {1}\r\n", message.Timestamp, message.Caption.Trim(), severity);
}
if (string.IsNullOrEmpty(message.Description) == false)
{
Write("{0}\r\n", message.Description.Trim());
}
Write("Category: {0} from {1}", message.CategoryName, message.LogSystem);
if (string.IsNullOrEmpty(message.ClassName) == false)
{
Write(" {0}.{1}", message.ClassName, message.MethodName);
}
if (string.IsNullOrEmpty(message.FileName) == false)
{
Write(" in {0} ({1})", message.FileName, message.LineNumber);
}
WriteLine();
Write("Thread: {0} ({1}) for {2}\r\n", message.ThreadName, message.ThreadId, message.UserName);
IExceptionInfo currentException = message.Exception;
if (currentException != null)
{
if (Config.IncludeExceptionDetails)
{
var label = "EXCEPTION";
while (currentException != null)
{
Write("{0}: {1} - {2} from {3}\r\nStack Trace:\r\n{4}\r\n",
label, currentException.TypeName, currentException.Message.Trim(),
currentException.Source, currentException.StackTrace);
currentException = currentException.InnerException;
label = "INNER EXCEPTION";
}
}
else
{
while (currentException != null)
{
Write("{0}: {1}\r\n", currentException.TypeName, currentException.Message.Trim());
currentException = currentException.InnerException;
}
}
WriteLine();
}
}
/// <summary>
/// Called by Loupe to have the configuration editor display itself and edit the provided configuration
/// </summary>
public DialogResult EditConfiguration(IRepositoryContext context, IRepositoryConfiguration configuration, bool initialConfiguration)
{
_context = context;
_context.Log.Verbose(ExtentionDefinition.LogCategory, "Begin editing Session Alert config", null);
var newConfig = configuration.Common as FindByUserConfiguration ?? new FindByUserConfiguration();
DisplayConfiguration(newConfig);
DialogResult result = ShowDialog();
if (result == DialogResult.OK)
{
//copy back our changes, but first make a clone to allow change logging
var oldConfig = newConfig.Clone();
newConfig.DatabaseProvider = cboProvider.Text;
newConfig.ConnectionString = txtConnectionString.Text;
newConfig.AutoScanSessions = chkEnableAutoScan.Checked;
configuration.Common = newConfig; // this is redundant except in the crucial first-time initialization case!
LogConfigurationChanges(newConfig, oldConfig);
}
else
{
_context.Log.Verbose(ExtentionDefinition.LogCategory, "Canceling FindByUser config dialog", null);
}
return result;
}
public RelatedAlbumsQuery(IRepositoryContext<Album> ctx) {
ParamIs.NotNull(() => ctx);
this.ctx = ctx;
}
public UserServiceImpl(
IRepositoryContext repositoryContext,
IUserRepository userRepository
)
: base(repositoryContext)
{
_userRpository = userRepository;
}
public SystemServiceImpl(IRepositoryContext context,
IRepository<Employee> employeeRepository,
IRepository<Menu> menuRepository)
: base(context)
{
_employeeRepository = employeeRepository;
_menuRepository = menuRepository;
}
/// <summary>
/// Called to initialize the add in.
/// </summary>
/// <remarks>
/// If any exception is thrown during this call the Add In will not be loaded.
/// </remarks>
public void Initialize(IRepositoryContext context)
{
if (_initialized)
throw new InvalidOperationException("The add-in has already been initialized and shouldn't be re-initialized");
_initialized = true;
_addInContext = context;
}
public DomainService(IRepositoryContext repositoryContext,
IPostRepository postRepository,
ICommentRepository commentRepository)
{
this.repositoryContext = repositoryContext;
this.postRepository = postRepository;
this.commentRepository = commentRepository;
}
public static Dictionary<string, Tag> GetTags(IRepositoryContext<Tag> session, string[] tagNames) {
if (tagNames.Length < 20) {
var direct = session.Query().Where(t => tagNames.Contains(t.Name)).ToArray();
return direct.Union(direct.Where(t => t.AliasedTo != null).Select(t => t.AliasedTo)).ToDictionary(t => t.Name, StringComparer.InvariantCultureIgnoreCase);
} else {
return session.Query().ToDictionary(t => t.Name, StringComparer.InvariantCultureIgnoreCase);
}
}
/// <summary>
/// 初始化一个<c>MessageServiceImpl</c>类型的实例。
/// </summary>
public MessageServiceImpl(IRepositoryContext context,
IMessageRepository messageRepository,
IContactRepository contactRepository,
ISendMessageService sendMessageService)
: base(context)
{
this.messageRepository = messageRepository;
this.contactRepository = contactRepository;
this.sendMessageService = sendMessageService;
}
/// <summary>
/// Create a TXT file for exporting log messages
/// </summary>
static public StreamWriter CreateLogStream(IRepositoryContext context, ExportAddInConfiguration config, ISession session)
{
var info = session.Summary;
var subFolder = Path.Combine(info.Product, info.Application);
var fileName = info.EndDateTime.ToString("yyyy-MM-dd HH-mm-ss") + " on " + info.HostName;
if (config.UseUniqueFilenames)
fileName += " " + info.Id;
return CreateStream(context, config.SessionExportPath, subFolder, fileName, ".txt");
}
public ProductServiceImp(IRepositoryContext context,
IProductRepository productRepository,
ICategoryRepository categoryRepository,
IProductCategorizationRepository productCategorizationRepository,
IDomainService domainService) :base(context)
{
_categoryRepository = categoryRepository;
_productRepository = productRepository;
_productCategorizationRepository = productCategorizationRepository;
_domainService = domainService;
}
public PostService(IRepositoryContext repositoryContext,
ITopicRepository topicRepository,
IUserRepository userRepository,
IPostRepository postRepository,
IDomainService domainService) : base(repositoryContext)
{
this.topicRepository = topicRepository;
this.userRepository = userRepository;
this.postRepository = postRepository;
this.domainService = domainService;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
if (_initialized)
_initialized = false;
if (_isDisposed)
throw new InvalidOperationException("The add-in has already been disposed");
_addInContext = null;
_isDisposed = true;
}
/// <summary>
/// 初始化一个<c>ProductServiceImpl</c>类型的实例。
/// </summary>
/// <param name="context">用来初始化<c>ProductServiceImpl</c>类型的仓储上下文实例。</param>
/// <param name="laptopRepository">“笔记本电脑”仓储实例。</param>
public ProductServiceImpl(IRepositoryContext context,
ICategoryRepository categoryRepository,
IProductRepository productRepository,
ICategorizationRepository categorizationRepository,
IDomainService domainService)
: base(context)
{
this.categoryRepository = categoryRepository;
this.productRepository = productRepository;
this.categorizationRepository = categorizationRepository;
this.domainService = domainService;
}
/// <summary>
/// 初始化一个新的<c>DomainService</c>类型的实例。
/// </summary>
/// <param name="repositoryContext">仓储上下文。</param>
/// <param name="categorizationRepository">商品分类关系仓储。</param>
/// <param name="userRoleRepository">用户角色关系仓储。</param>
/// <param name="shoppingCartItemRepository">购物篮项目仓储。</param>
/// <param name="salesOrderRepository">销售订单仓储。</param>
public DomainService(IRepositoryContext repositoryContext,
ICategorizationRepository categorizationRepository,
IUserRoleRepository userRoleRepository,
IShoppingCartItemRepository shoppingCartItemRepository,
ISalesOrderRepository salesOrderRepository)
{
_repositoryContext = repositoryContext;
_categorizationRepository = categorizationRepository;
_userRoleRepository = userRoleRepository;
_shoppingCartItemRepository = shoppingCartItemRepository;
_salesOrderRepository = salesOrderRepository;
}
/// <summary>
/// Create a CSV for a metric that contains multiple instances
/// </summary>
public static StreamWriter CreateMetricInstanceStream(IRepositoryContext context, ExportAddInConfiguration config, ISession session, IMetric metric, ref int metricFileCount)
{
var info = session.Summary;
var subFolder = Path.Combine(info.Product, info.Application);
var metricName = metric.CategoryName + "." + metric.CounterName + "." + metric.InstanceName;
subFolder = Path.Combine(subFolder, metricName);
var fileName = info.EndDateTime.ToString("yyyy-MM-dd HH-mm-ss") + " on " + info.HostName;
fileName += " (" + ++metricFileCount + ")"; // Uniquify filename for convenience with Excel
if (config.UseUniqueFilenames)
fileName += " " + info.Id;
return CreateStream(context, config.SessionExportPath, subFolder, fileName, ".csv");
}
/// <summary>
/// Called to initialize the session analyzer.
/// </summary>
/// <param name="context">A standard interface to the hosting environment for the analyzer</param>
/// <remarks>
/// If any exception is thrown during this call this add in will not be loaded.
/// The analyzer can keep the context object for its entire lifespan
/// </remarks>
public void Initialize(IRepositoryContext context)
{
if (m_Initialized)
throw new InvalidOperationException("The add-in has already been initialized and shouldn't be re-initialized");
m_Context = context;
m_Controller = (RepositoryController)m_Context.RepositoryController;
//load up our baseline configuration
ConfigurationChanged();
m_Initialized = true;
}
public UserServiceImp(IRepositoryContext repositoryContext,
IUserRepository userRepository,
IShoppingCartRepository shoppingCartRepository,
IDomainService domainService,
IRoleRepository roleRepository,
IUserRoleRepository userRoleRepository)
: base(repositoryContext)
{
_userRepository = userRepository;
_shoppingCartRepository = shoppingCartRepository;
_domainService = domainService;
_roleRepository = roleRepository;
_userRoleRepository = userRoleRepository;
}
protected override void ConfigureApplicationContainer(TinyIoCContainer container)
{
base.ConfigureApplicationContainer(container);
repositoryContext = new MongoContext(
ConfigurationManager.AppSettings["ConnectionString"], "Encore");
poolPartyClient = new PoolPartyClient(
ConfigurationManager.AppSettings["PoolParty.EncoreUrl"],
ConfigurationManager.AppSettings["PoolParty.UserName"],
ConfigurationManager.AppSettings["PoolParty.Password"]);
container.Register<IRepositoryContext>(repositoryContext);
container.Register<IProvideFieldData>(poolPartyClient);
}
/// <summary>
/// 初始化一个<c>OrderServiceImpl</c>类型的实例。
/// </summary>
/// <param name="context">用来初始化<c>OrderServiceImpl</c>类型的仓储上下文实例。</param>
/// <param name="shoppingCartRepository">“购物篮”仓储实例。</param>
/// <param name="shoppingCartItemRepository">“购物篮项目”仓储实例。</param>
/// <param name="productRepository">“笔记本电脑”仓储实例。</param>
/// <param name="customerRepository">“客户”仓储实例。</param>
/// <param name="salesOrderRepository">“销售订单”仓储实例。</param>
public OrderServiceImpl(IRepositoryContext context,
IShoppingCartRepository shoppingCartRepository,
IShoppingCartItemRepository shoppingCartItemRepository,
IProductRepository productRepository,
IUserRepository customerRepository,
ISalesOrderRepository salesOrderRepository,
IDomainService domainService)
: base(context)
{
this.shoppingCartRepository = shoppingCartRepository;
this.shoppingCartItemRepository = shoppingCartItemRepository;
this.productRepository = productRepository;
this.userRepository = customerRepository;
this.salesOrderRepository = salesOrderRepository;
this.domainService = domainService;
}
/// <summary>
/// 初始化一个新的<c>UserServiceImpl</c>实例。
/// </summary>
/// <param name="context"></param>
/// <param name="userRepository"></param>
/// <param name="userRoleRepository"></param>
/// <param name="roleRepository"></param>
/// <param name="shoppingCartRepository"></param>
/// <param name="salesOrderRepository"></param>
/// <param name="domainService"></param>
public UserServiceImpl(IRepositoryContext context,
IUserRepository userRepository,
IUserRoleRepository userRoleRepository,
IRoleRepository roleRepository,
IShoppingCartRepository shoppingCartRepository,
ISalesOrderRepository salesOrderRepository,
IDomainService domainService)
: base(context)
{
this.userRepository = userRepository;
this.userRoleRepository = userRoleRepository;
this.roleRepository = roleRepository;
this.shoppingCartRepository = shoppingCartRepository;
this.salesOrderRepository = salesOrderRepository;
this.domainService = domainService;
}
public DomainService(IRepositoryContext repositoryContext,
IOrderRepository orderRepository,
IShoppingCartItemRepository shoppingCartItemRepository,
ICategoryRepository categoryRepository,
IProductCategorizationRepository productCategorizationRepository,
IProductRepository productRepository,
IUserRepository userRepository,
IRoleRepository roleRepository,
IUserRoleRepository userRoleRepository)
{
_repositoryContext = repositoryContext;
_orderRepository = orderRepository;
_shoppingCartItemRepository = shoppingCartItemRepository;
_productCategorizationRepository = productCategorizationRepository;
_userRoleRepository = userRoleRepository;
}
/// <summary>
/// Shared logic for creating all streams
/// </summary>
static StreamWriter CreateStream(IRepositoryContext context, string baseFolder, string subFolder, string fileName, string filetype)
{
// Guard against illegal characters
subFolder = illegalInPath.Replace(subFolder, "_");
fileName = illegalInFileName.Replace(fileName, "_");
// Ensure the folder exists
string folder = Path.Combine(baseFolder, subFolder);
if (Directory.Exists(folder) == false)
Directory.CreateDirectory(folder);
// Create the stream
string fullPath = Path.Combine(folder, fileName + filetype);
context.Log.Verbose(LogCategory, "Creating file to export session data", fullPath);
return new StreamWriter(fullPath);
}
public OrderServiceImp(IRepositoryContext context,
IUserRepository userRepository,
IShoppingCartRepository shoppingCartRepository,
IProductRepository productRepository,
IShoppingCartItemRepository shoppingCartItemRepository,
IDomainService domainService,
IOrderRepository orderRepository,
IEventBus eventBus) : base(context)
{
_userRepository = userRepository;
_shoppingCartRepository = shoppingCartRepository;
_productRepository = productRepository;
_shoppingCartItemRepository = shoppingCartItemRepository;
_domainService = domainService;
_orderRepository = orderRepository;
_eventBus = eventBus;
}
private readonly ITeacherDeclarationRepository _teaDeclRepo; // = ServiceLocator.Current.GetInstance<ITeacherDeclarationRepository>();
#endregion Fields
#region Constructors
public SubscriptionAppl(ITypeAdapter adapter,
IStudentDeclarationJiaoWuRepository stuDeclJiaoWuRepo,
ITeacherDeclarationJiaoWuRepository teaDeclJiaoWuRepo,
IStudentDeclarationRepository stuDeclRepo,
ITeacherDeclarationRepository teaDeclRepo,
ISubscriptionRepository subscriptionRepo,
IRepositoryContext context
)
{
_adapter = adapter;
_stuDeclRepo = stuDeclRepo;
_teaDeclRepo = teaDeclRepo;
_stuDeclJiaoWuRepo = stuDeclJiaoWuRepo;
_teaDeclJiaoWuRepo = teaDeclJiaoWuRepo;
_subscriptionRepo = subscriptionRepo;
_contextForUpdate = context;
}
public MenuService(IRepositoryContext context)
{
_context = context;
}
public DepartmentRepository(IRepositoryContext context)
: base(context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountAuthenticatedEventHandler"/> class.
/// </summary>
/// <param name="repositoryContext">The repository context.</param>
public AccountAuthenticatedEventHandler(IRepositoryContext repositoryContext)
{
this.repositoryContext = repositoryContext;
this.authenticationRepository = this.repositoryContext.GetRepository <Guid, Authentication>();
}
public Base_BankRepository(IRepositoryContext context)
: base(context)
{
}
public ActionRepository(IRepositoryContext context) : base(context)
{
}
public UserService(IRepositoryContext context, IRepository <User> repository) : base(context, repository)
{
}
public UserRoleRepository(IRepositoryContext context)
: base(context)
{
}
public ApplicationService(IRepositoryContext repositoryContext)
{
this.repositoryContext = repositoryContext;
}
public AskRecordRepository(IRepositoryContext context) : base(context)
{
}
/// <summary>
/// Initializes a new instance of <c>Repository<TAggregateRoot></c> class.
/// </summary>
/// <param name="context">The repository context being used by the repository.</param>
public Repository(IRepositoryContext context)
{
this.context = context;
}
public TeacherRepository(IRepositoryContext context)
: base(context)
{
}
public InStockRecordRepository(IRepositoryContext context)
: base(context)
{
}
public F_ADService(IRepositoryContext context,
IF_ADRepository iF_ADRepository)
: base(context)
{
this._IF_ADRepository = iF_ADRepository;
}
public Repository(IRepositoryContext context)
: base(context)
{
}
public HM_VillageRepository(IRepositoryContext context)
: base(context)
{
}
public UserLoginService(IComponentContext iocContext, IRepositoryContext context) : base(iocContext, context)
{
}
public Empresa(IRepositoryContext repositoryContext)
: base(repositoryContext)
{
}
public BooksellerRepository(IRepositoryContext context)
: base(context)
{
}
public ArtistRelationsQuery(IRepositoryContext <Artist> ctx, ContentLanguagePreference languagePreference)
{
this.ctx = ctx;
this.languagePreference = languagePreference;
}
public G_ActivityService(IRepositoryContext context,
IG_ActivityRepository IG_ActivityRepository)
: base(context)
{
this._IG_ActivityRepository = IG_ActivityRepository;
}
public G_UserDetailRepository(IRepositoryContext context)
: base(context)
{
}
public AppAccountService(IRepositoryContext context, IAppAccountRepository appAccountRepository) : base(context)
{
this.appAccountRepository = appAccountRepository;
}
public RegularEventPublisherDomainRepository(IRepositoryContext context, IEventBus eventBus)
: base(eventBus)
{
this.context = context;
}
public F_NewsRepository(IRepositoryContext context)
: base(context)
{
}
public F_WithdrawDepositRecordRepository(IRepositoryContext context)
: base(context)
{
}
public F_CreditCardStoreRepository(IRepositoryContext context)
: base(context)
{
}
/// <summary>
/// 初始化<c>Repository</c>实例
/// </summary>
/// <param name="context">于仓储的仓储上下文</param>
protected Repository(IRepositoryContext context)
{
this.context = context;
}
/// <summary>
/// 通过构造函数注入得到数据上下文对象实例
/// </summary>
/// <param name="dbContext"></param>
public EntityFrameworkRepositoryBase(IRepositoryContext context) : base(context)
{
var entityFrameworkRepositoryContext = (EntityFrameworkRepositoryContext)context;
_dbContext = entityFrameworkRepositoryContext.Session;
}
public RepositoryContextAsyncWrapper([NotNull] IRepositoryContext context)
{
_underlyingContext = Guard.NotNull(context, nameof(context));
}
/// <summary>
/// Initializes a new instance of the <see cref="AsEmployeeService"/> class.
/// </summary>
/// <param name="unity">The unity.</param>
/// <param name="context">The context.</param>
public AsEmployeeService(IUnityContainer unity, IRepositoryContext context)
: base(unity, context)
{
}
