public ActionResult Index(int?id)
{
ViewBag.ActiveMenu = 1;
SubscriptionV areaModel = new SubscriptionV();
if (id != null)
{
using (SubscriptionRepository vehiclesProxy = new SubscriptionRepository())
{
areaModel = vehiclesProxy.GetById((int)id);
}
return(PartialView("_AddSubscription", areaModel));
}
else
{
if (Request.IsAjaxRequest())
{
return(PartialView("_AddSubscription", areaModel));
}
else
{
return(View(areaModel));
}
}
}
public OctopusAsyncRepository(IOctopusAsyncClient client, RepositoryScope repositoryScope = null)
{
Client = client;
Scope = repositoryScope ?? RepositoryScope.Unspecified();
Accounts = new AccountRepository(this);
ActionTemplates = new ActionTemplateRepository(this);
Artifacts = new ArtifactRepository(this);
Backups = new BackupRepository(this);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this);
CertificateConfiguration = new CertificateConfigurationRepository(this);
Certificates = new CertificateRepository(this);
Channels = new ChannelRepository(this);
CommunityActionTemplates = new CommunityActionTemplateRepository(this);
Configuration = new ConfigurationRepository(this);
DashboardConfigurations = new DashboardConfigurationRepository(this);
Dashboards = new DashboardRepository(this);
Defects = new DefectsRepository(this);
DeploymentProcesses = new DeploymentProcessRepository(this);
Deployments = new DeploymentRepository(this);
Environments = new EnvironmentRepository(this);
Events = new EventRepository(this);
FeaturesConfiguration = new FeaturesConfigurationRepository(this);
Feeds = new FeedRepository(this);
Interruptions = new InterruptionRepository(this);
LibraryVariableSets = new LibraryVariableSetRepository(this);
Lifecycles = new LifecyclesRepository(this);
MachinePolicies = new MachinePolicyRepository(this);
MachineRoles = new MachineRoleRepository(this);
Machines = new MachineRepository(this);
Migrations = new MigrationRepository(this);
OctopusServerNodes = new OctopusServerNodeRepository(this);
PerformanceConfiguration = new PerformanceConfigurationRepository(this);
PackageMetadataRepository = new PackageMetadataRepository(this);
ProjectGroups = new ProjectGroupRepository(this);
Projects = new ProjectRepository(this);
ProjectTriggers = new ProjectTriggerRepository(this);
Proxies = new ProxyRepository(this);
Releases = new ReleaseRepository(this);
RetentionPolicies = new RetentionPolicyRepository(this);
Schedulers = new SchedulerRepository(this);
ServerStatus = new ServerStatusRepository(this);
Spaces = new SpaceRepository(this);
Subscriptions = new SubscriptionRepository(this);
TagSets = new TagSetRepository(this);
Tasks = new TaskRepository(this);
Teams = new TeamsRepository(this);
Tenants = new TenantRepository(this);
TenantVariables = new TenantVariablesRepository(this);
UserInvites = new UserInvitesRepository(this);
UserRoles = new UserRolesRepository(this);
Users = new UserRepository(this);
VariableSets = new VariableSetRepository(this);
Workers = new WorkerRepository(this);
WorkerPools = new WorkerPoolRepository(this);
ScopedUserRoles = new ScopedUserRoleRepository(this);
UserPermissions = new UserPermissionsRepository(this);
loadRootResource = new Lazy <Task <RootResource> >(LoadRootDocumentInner, true);
loadSpaceRootResource = new Lazy <Task <SpaceRootResource> >(LoadSpaceRootDocumentInner, true);
}
public void SaveSubscriptionWithStudentDeclaration()
{
//取未征订学生申报
var studentDeclarations = _appl.GetNotSubscriptionStudentDeclarationJiaoWu("2013-2014-2");
var teacherDeclarations = _appl.GetNotSubscriptionTeacherDeclarationJiaoWu("2013-2014-2");
//生成订单
var subscriptions = SubscriptionService.CreateSubscriptionsByPress(studentDeclarations, teacherDeclarations);
//保存
var repo = new SubscriptionRepository(_context);
for (int i = 0; i < subscriptions.Count(); i = i + 300)
{
foreach (var item in subscriptions.Skip(i).Take(300))
{
repo.Add(item);
}
repo.Context.Commit();
}
var ids = subscriptions.Select(d => d.ID);
var result = repo.Find(t => ids
.Contains(t.ID)
);
Assert.AreEqual(subscriptions.Count(), result.Count());
}
public FeedController(SubscriptionRepository subscriptionRepo,
PostRepository postRepo)
{
_subscriptionRepo = subscriptionRepo;
_postRepo = postRepo;
model = new FeedViewModel();
}
public SubscriptionRouterService(IServiceBus bus, SubscriptionRepository repository, string network)
{
_peerUri = bus.ControlBus.Endpoint.Address.Uri;
_repository = repository;
_network = network;
_peerId = NewId.NextGuid();
_observers = new List<SubscriptionObserver>();
_listeners = new List<BusSubscriptionEventListener>();
_unregister = () => true;
_peerUri = bus.ControlBus.Endpoint.Address.Uri;
var connector = new BusSubscriptionConnector(bus);
_peerCache = ActorFactory.Create<PeerCache>(x =>
{
x.ConstructedBy((fiber, scheduler, inbox) =>
new PeerCache(connector, _peerId, _peerUri, repository));
x.UseSharedScheduler();
x.HandleOnPoolFiber();
})
.GetActor();
// at this point, existing subscriptions need to be loaded...
_repository.Load(this);
}
public static SubscriptionRepository GetSubscriptionRepository(IUnitOfWork unitOfWork)
{
var repository = new SubscriptionRepository();
repository.UnitOfWork = unitOfWork;
return(repository);
}
public void GetSubscription()
{
var repo = new SubscriptionRepository(_context);
var result = repo.Find(t => t.SchoolYearTerm.Year == "2013-2014" && t.SchoolYearTerm.Term == "2");
Assert.IsTrue(result.Count() > 0);
}
public void When_GetSubscriptionIsCalled_AndSubscriptionIsNotPresent_Then_SubscriptionListIsEmpty()
{
var repository = new SubscriptionRepository();
var subscription1 = new SubscriptionDataModel
{
Username = "******",
AccessToken = "testtoken",
TotalNotificationsPushed = 0,
};
repository.Add(subscription1);
var subscription2 = new SubscriptionDataModel
{
Username = "******",
AccessToken = "newtoken",
TotalNotificationsPushed = 0,
};
repository.Add(subscription2);
var result = repository.GetSubscription("bbc1");
// Assert
Assert.IsNull(result);
}
public void When_UpdateIsCalled_AndSubscriptionIsNotPresent_Then_FalseIsReturned()
{
var repository = new SubscriptionRepository();
var subscription1 = new SubscriptionDataModel
{
Username = "******",
AccessToken = "testtoken",
TotalNotificationsPushed = 0,
};
repository.Add(subscription1);
var subscription2 = new SubscriptionDataModel
{
Username = "******",
AccessToken = "newtoken",
TotalNotificationsPushed = 0,
};
repository.Add(subscription2);
var result = repository.Update(new SubscriptionDataModel {
AccessToken = "newToken", Username = "******"
});
// Assert
Assert.IsFalse(result);
}
public void When_GetSubscriptionIsCalled_AndSubscriptionIsPresent_Then_SubscriptionIsReturned()
{
var repository = new SubscriptionRepository();
var subscription1 = new SubscriptionDataModel
{
Username = "******",
AccessToken = "testtoken",
TotalNotificationsPushed = 0,
};
repository.Add(subscription1);
var subscription2 = new SubscriptionDataModel
{
Username = "******",
AccessToken = "newtoken",
TotalNotificationsPushed = 0,
};
repository.Add(subscription2);
var result = repository.GetSubscription("bbc");
// Assert
Assert.AreEqual(subscription1.Username, result.Username);
Assert.AreEqual(subscription1.AccessToken, result.AccessToken);
}
public static void PreWarm(this IApplicationBuilder applicationBuilder)
{
Startup.LoadTypes();
var internalSubscriptionService = bool.Parse(ConfigurationReader.GetValue("InternalSubscriptionService"));
if (internalSubscriptionService)
{
String eventStoreConnectionString = ConfigurationReader.GetValue("EventStoreSettings", "ConnectionString");
Int32 inflightMessages = int.Parse(ConfigurationReader.GetValue("AppSettings", "InflightMessages"));
Int32 persistentSubscriptionPollingInSeconds = int.Parse(ConfigurationReader.GetValue("AppSettings", "PersistentSubscriptionPollingInSeconds"));
String filter = ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionServiceFilter");
String ignore = ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionServiceIgnore");
String streamName = ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionFilterOnStreamName");
Int32 cacheDuration = int.Parse(ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionServiceCacheDuration"));
ISubscriptionRepository subscriptionRepository = SubscriptionRepository.Create(eventStoreConnectionString, cacheDuration);
((SubscriptionRepository)subscriptionRepository).Trace += (sender,
s) => Extensions.log(TraceEventType.Information, "REPOSITORY", s);
// init our SubscriptionRepository
subscriptionRepository.PreWarm(CancellationToken.None).Wait();
var eventHandlerResolver = Startup.ServiceProvider.GetService <IDomainEventHandlerResolver>();
SubscriptionWorker concurrentSubscriptions =
SubscriptionWorker.CreateConcurrentSubscriptionWorker(eventStoreConnectionString,
eventHandlerResolver,
subscriptionRepository,
inflightMessages,
persistentSubscriptionPollingInSeconds);
concurrentSubscriptions.Trace += (_,
args) => Extensions.concurrentLog(TraceEventType.Information, args.Message);
concurrentSubscriptions.Warning += (_,
args) => Extensions.concurrentLog(TraceEventType.Warning, args.Message);
concurrentSubscriptions.Error += (_,
args) => Extensions.concurrentLog(TraceEventType.Error, args.Message);
if (!string.IsNullOrEmpty(ignore))
{
concurrentSubscriptions = concurrentSubscriptions.IgnoreSubscriptions(ignore);
}
if (!string.IsNullOrEmpty(filter))
{
//NOTE: Not overly happy with this design, but
//the idea is if we supply a filter, this overrides ignore
concurrentSubscriptions = concurrentSubscriptions.FilterSubscriptions(filter).IgnoreSubscriptions(null);
}
if (!string.IsNullOrEmpty(streamName))
{
concurrentSubscriptions = concurrentSubscriptions.FilterByStreamName(streamName);
}
concurrentSubscriptions.StartAsync(CancellationToken.None).Wait();
}
}
public SubscriptionRouterService(IServiceBus bus, SubscriptionRepository repository, string network)
{
_peerUri = bus.ControlBus.Endpoint.Address.Uri;
_repository = repository;
_network = network;
_peerId = NewId.NextGuid();
_observers = new List <SubscriptionObserver>();
_listeners = new List <BusSubscriptionEventListener>();
_unregister = () => true;
_peerUri = bus.ControlBus.Endpoint.Address.Uri;
var connector = new BusSubscriptionConnector(bus);
_peerCache = ActorFactory.Create <PeerCache>(x =>
{
x.ConstructedBy((fiber, scheduler, inbox) =>
new PeerCache(connector, _peerId, _peerUri, repository));
x.UseSharedScheduler();
x.HandleOnPoolFiber();
})
.GetActor();
// at this point, existing subscriptions need to be loaded...
_repository.Load(this);
}
public UnitOfWork(EasyFindPropertiesEntities dbCtx)
{
_dbCtx = dbCtx;
PropertyType = new PropertyTypeRepository(_dbCtx);
AdPriority = new AdPriorityRepository(_dbCtx);
AdType = new AdTypeRepository(_dbCtx);
PropertyCategory = new PropertyCategoryRepository(_dbCtx);
PropertyCondition = new PropertyConditionRepository(_dbCtx);
PropertyImage = new PropertyImageRepository(_dbCtx);
PropertyPurpose = new PropertyPurposeRepository(_dbCtx);
PropertyRating = new PropertyRatingRepository(_dbCtx);
Property = new PropertyRepository(_dbCtx);
PropertyRequisition = new PropertyRequisitionRepository(_dbCtx);
SubscriptionType = new SubscriptionTypeRepository(_dbCtx);
Subscription = new SubscriptionRepository(_dbCtx);
TagType = new TagTypeRepository(_dbCtx);
Tennant = new TennantRepository(_dbCtx);
Owner = new OwnerRepository(_dbCtx);
Tags = new TagsRepository(_dbCtx);
Message = new MessageRepository(_dbCtx);
User = new UserRepository(_dbCtx);
UserType = new UserTypeRepository(_dbCtx);
UserTypeAssoc = new UserTypeAssocRepository(_dbCtx);
MessageTrash = new MessageTrashRepository(_dbCtx);
Meeting = new MeetingRepository(_dbCtx);
MeetingMembers = new MeetingMembersRepository(_dbCtx);
}
public SubscriptionController()
{
_repo = new VetRepository(new FnRDbContext());
_subRepo = new SubscriptionRepository(new FnRDbContext());
_userRepo = new UserRepository(new FnRDbContext());
_productRepo = new ProductRepository(new FnRDbContext());
}
public ProductController(ILogger <ProductController> logger, VitecContext context)
{
_logger = logger;
_context = context;
_productRepository = new ProductRepository(_connectionString + "/api/products");
_subscriptionRepository = new SubscriptionRepository(_connectionString + "/api/subscriptions");
_priceRepository = new PriceRepository(_connectionString + "/api/prices");
}
public static void Main()
{
var repo = new SubscriptionRepository();
ProgramUI ui = new ProgramUI(repo, new Repository.Console());
repo.AddInitialContent();
ui.Run();
}
public CheckStrategy(UserModel user,
SubscriptionRepository repo,
ISnowForecastClient snowForecastClient)
{
_user = user;
_repo = repo;
_snowForecastClient = snowForecastClient;
}
private void OnSubscriptionCreating()
{
Hub.Default.Subscribe((MessageEventArgs args) =>
{
SubscriptionRepository.CreateSubscription(new Subscription(args.Message.Chat.Id,
"https://wykop.pl/"));
});
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
TraineeRepository = new TraineeRepository(context);
SubscriptionRepository = new SubscriptionRepository(context);
TraineeSubscriptionRepository = new TraineeSubscriptionRepository(context);
TraineeSubscriptionsDetailRepository = new TraineeSubscriptionsDetailRepository(context);
}
public PaymentsUnitOfWork(PaymentsContext context)
{
_context = context;
ProductRepository = new ProductRepository(context);
PaymentRepository = new PaymentRepository(context);
PayPalPlanRepository = new PayPalPlanRepository(context);
SubscriptionRepository = new SubscriptionRepository(context);
}
public void GetTeacherDeclarationsInSubscription()
{
var repo = new SubscriptionRepository(_context);
var id = "5B9B37F5-E6CA-4783-AC12-2C1AFD1BD414".ConvertToGuid();
var result = repo.Single(t => t.ID == id);
Assert.IsTrue(result.TeacherDeclarations.Count > 0);
}
public PostController(IConfiguration config)
{
_postRepository = new PostRepository(config);
_categoryRepository = new CategoryRepository(config);
_commentRepository = new CommentRepository(config);
_postTagRepository = new PostTagRepository(config);
_postTagRepo = new PostTagRepository(config);
_subRepo = new SubscriptionRepository(config);
}
public async Task <Subscription> GetItems(Verification person)
{
var request = new Subscription {
Email = person.Email
};
var repo = new SubscriptionRepository();
return(await repo.ReadByEmail(request.Email));
}
public ActionResult ChangeDone(int uId, bool activeV)
{
using (SubscriptionRepository secUserRepo = new SubscriptionRepository())
{
secUserRepo.DoneById(uId, activeV);
}
return(Json(new { success = reqResponse.IsDone, message = reqResponse.IsDone ? OperationLP.SuccessMsg : reqResponse.ErrorMessegesStr }));
}
public SchedulerController(IMessanger messanger,
SnowfallChecker snowfallChecker,
UserRepository userRepo,
SubscriptionRepository subscriptionRepo)
{
_messanger = messanger;
_snowfallChecker = snowfallChecker;
_userRepo = userRepo;
_subscriptionRepo = subscriptionRepo;
}
public void When_AddIsCalled_AndSubscriptionIsNull_Then_SubscriptionIsNotAddedAndNullIsReturned()
{
SubscriptionDataModel subscription = null;
var repository = new SubscriptionRepository();
var result = repository.Add(subscription);
// Assert
Assert.IsNull(result);
}
public CourseController(SubscriberRepository subscriberRepository,
AuthorRepository authorRepository, CourseRepository courseRepository,
SubscriptionRepository subscriptionRepository, SubjectRepository subjectRepository)
{
this.authorRepository = authorRepository;
this.subscriberRepository = subscriberRepository;
this.courseRepository = courseRepository;
this.subscriptionRepository = subscriptionRepository;
this.subjectRepository = subjectRepository;
}
public EndpointSubscriptionCache(SubscriptionObserver observer, Uri peerUri,
SubscriptionRepository repository)
{
_observer = observer;
_peerUri = peerUri;
_messageSubscriptions =
new DictionaryCache<SubscriptionKey, EndpointSubscription>(
key =>
new EndpointSubscription(_peerUri, key.MessageName, key.CorrelationId, _observer,
repository));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
var repository = new SubscriptionRepository();
services.AddSingleton <ISubscriptionRepository>(repository);
services.AddTransient <IHttpClientWrapper, HttpClientWrapper>();
services.AddTransient <INotificationsService, PushBulletNotificationsService>();
}
public EndpointSubscriptionCache(SubscriptionObserver observer, Uri peerUri,
SubscriptionRepository repository)
{
_observer = observer;
_peerUri = peerUri;
_messageSubscriptions =
new DictionaryCache <SubscriptionKey, EndpointSubscription>(
key =>
new EndpointSubscription(_peerUri, key.MessageName, key.CorrelationId, _observer,
repository));
}
public void SetUp()
{
persistence = new InMemorySubscriptionPersistence();
channelGraph = new ChannelGraph {
Name = TheNodeName
};
channelGraph.AddReplyChannel("foo", "foo://replies".ToUri());
channelGraph.AddReplyChannel("bar", "bar://replies".ToUri());
theRepository = new SubscriptionRepository(channelGraph, persistence);
}
public PeerCache(SubscriptionObserver observer, Guid clientId, Uri controlUri, SubscriptionRepository repository)
{
_peers = new DictionaryCache<Uri, ActorRef>();
_peerUri = controlUri;
_peerIds = new DictionaryCache<Guid, Uri>();
_peerHandlerFactory = ActorFactory.Create((f, s, i) => new PeerHandler(i, observer, repository));
// create a peer for our local client
WithPeer(clientId, controlUri, x => { }, true);
}
public HomeController()
{
this.CardRepo = new CardRepository();
this.CauseRepo = new CauseRepository();
this.HelpOptionRepo = new HelpOptionRepository();
this.HomePageVideoRepo = new HomePageVideoRepository();
this.MissionRepo = new MissionRepository();
this.WhyUsRepo = new WhyUsRepository();
this.ContactRepo = new ContactRepository();
this.SubscriptionRepo = new SubscriptionRepository();
}
public async Task SubscriptionRepository_GetSubscriptions_ReturnsSubscriptions()
{
List <PersistentSubscriptionInfo> allSubscriptions = (TestData.GetPersistentSubscriptions_DemoEstate());
Func <CancellationToken, Task <List <PersistentSubscriptionInfo> > > GetAllSubscriptions = async token => allSubscriptions;
ISubscriptionRepository subscriptionRepository = SubscriptionRepository.Create(GetAllSubscriptions);
PersistentSubscriptions list = await subscriptionRepository.GetSubscriptions(true, CancellationToken.None);
list.PersistentSubscriptionInfo.Count.ShouldBe(allSubscriptions.Count);
}
public EndpointSubscription(Uri peerUri, string messageName, string correlationId,
SubscriptionObserver observer, SubscriptionRepository repository)
{
_peerUri = peerUri;
_messageName = messageName;
_correlationId = correlationId;
_observer = observer;
_repository = repository;
_ids = new Dictionary<Guid, PeerSubscription>();
_subscriptionId = Guid.Empty;
}
public PeerHandler(Inbox inbox, SubscriptionObserver observer,
SubscriptionRepository repository)
{
_observer = observer;
inbox.Receive<InitializePeerHandler>(init =>
{
_peerId = init.PeerId;
_peerUri = init.PeerUri;
_endpointSubscriptionCache = new EndpointSubscriptionCache(observer, _peerUri,
repository);
});
}
public OctopusRepository(IOctopusClient client)
{
this.Client = client;
Feeds = new FeedRepository(client);
Backups = new BackupRepository(client);
Machines = new MachineRepository(client);
MachineRoles = new MachineRoleRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
Subscriptions = new SubscriptionRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
Proxies = new ProxyRepository(client);
Tasks = new TaskRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Releases = new ReleaseRepository(client);
Deployments = new DeploymentRepository(client);
Certificates = new CertificateRepository(client);
Dashboards = new DashboardRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Artifacts = new ArtifactRepository(client);
Interruptions = new InterruptionRepository(client);
ServerStatus = new ServerStatusRepository(client);
UserRoles = new UserRolesRepository(client);
Teams = new TeamsRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Accounts = new AccountRepository(client);
Defects = new DefectsRepository(client);
Lifecycles = new LifecyclesRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
Channels = new ChannelRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Schedulers = new SchedulerRepository(client);
Tenants = new TenantRepository(client);
TagSets = new TagSetRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
}
public void GetSubscriptionWithNotSubscription()
{
var repo = new SubscriptionRepository(_context);
var result = repo.Find(t =>
t.SchoolYearTerm.Year == "2013-2014" &&
t.SchoolYearTerm.Term == "2" &&
t.SubscriptionState == FeedbackState.未征订);
Assert.IsTrue(result.Count() > 0);
}
public void GetTeacherDeclarationsInSubscription()
{
var repo = new SubscriptionRepository(_context);
var id = "5B9B37F5-E6CA-4783-AC12-2C1AFD1BD414".ConvertToGuid();
var result = repo.Single(t => t.ID == id);
Assert.IsTrue(result.TeacherDeclarations.Count > 0);
}
public void SaveSubscriptionWithStudentDeclaration()
{
//取未征订学生申报
var studentDeclarations = _appl.GetNotSubscriptionStudentDeclarationJiaoWu("2013-2014-2");
var teacherDeclarations = _appl.GetNotSubscriptionTeacherDeclarationJiaoWu("2013-2014-2");
//生成订单
var subscriptions = SubscriptionService.CreateSubscriptionsByPress(studentDeclarations, teacherDeclarations);
//保存
var repo = new SubscriptionRepository(_context);
for (int i = 0; i < subscriptions.Count(); i = i + 300)
{
foreach (var item in subscriptions.Skip(i).Take(300))
{
repo.Add(item);
}
repo.Context.Commit();
}
var ids = subscriptions.Select(d => d.ID);
var result = repo.Find(t => ids
.Contains(t.ID)
);
Assert.AreEqual(subscriptions.Count(), result.Count());
}