public void Begin(IProcessRunner processRunner, IActorRepository repository)
{
_clock.Reset();
Double duration = TimeSpan.FromMilliseconds(0).TotalMilliseconds;
foreach (var child in Children)
{
Actor target = null;
if (!String.IsNullOrEmpty(child.TargetName))
target = repository.GetActorByName(child.TargetName);
else if (child.TargetActor != null)
target = child.TargetActor;
else
throw new Exception("A storyboard child was found that did not specify an actor name or actor.");
var targetProperty = child.TargetProperty;
child.Timeline.SetActor(target);
child.Timeline.ApplyAnimationClock(_clock);
child.Timeline.BeginAnimation(targetProperty);
duration = Math.Max(child.Timeline.GetNaturalDuration().TotalMilliseconds, duration);
}
processRunner.ScheduleProcess(new AnimationClockController(_clock, TimeSpan.FromMilliseconds(duration)));
}
public MoviesController(UserManager <AppUser> userManager, ApplicationDbContext context, IMovieRepository movieRepository, IActorRepository actorRepository)
{
_context = context;
_movieRepository = movieRepository;
_actorRepository = actorRepository;
_userManager = userManager;
}
public Cast(string n, int ind)
{
actorRepo = new SqlActorRepository(connectionString);
movieRepo = new SqlMovieRepository(connectionString);
reviewRepo = new SqlReviewRepository(connectionString);
showtimeRepo = new SqlShowTimeRepository(connectionString);
ticketRepo = new SqlTicketRepository(connectionString);
viewerRepo = new SqlViewerRepository(connectionString);
InitializeComponent();
index = ind;
name = n;
index = ind;
name = movieRepo.FetchMovie(ind).Name;
label1.Text = name;
IReadOnlyList <Actor> actors = actorRepo.FetchActorOnMovie(ind);
foreach (Actor a in actors)
{
listBox1.Items.Add(a.Name);
}
}
//Constructor
public MovieController()
{
_MovieRep = new MovieRepository(new MovieContext());
_ProRep = new ProducerRepository(new ProducerContext());
_ActRep = new ActorRepository(new ActorContext());
_MovActRep = new MovieActorRepository(new MovieActorContext(), new MovieActorModel());
}
public ActorUpdatedHandler(
IActorRepository actorRepository,
ILogger logger)
{
_actorRepository = actorRepository;
_logger = logger;
}
public ServerNode(INetProvider externalNetProvider, INetProvider internalNetProvider, INodeCoordinator coordinator,
IMessageFactory factory, IOperationDispatcher protocol, IActorRepository repository,
Func <S2CPeer> clientPeerFactory)
{
_coordinator = coordinator;
Repository = repository;
Dispatcher = protocol;
DefaultActorCoordinator = typeof(IsisActorCoordinator);
ExternalNet = new NetNode <S2CPeer>(externalNetProvider, factory, protocol,
peerFactory: () =>
{
S2CPeer peer = clientPeerFactory();
peer.Node = this;
return(peer);
});
InternalNet = new NetNode <S2SPeer>(internalNetProvider, factory, protocol,
peerFactory: () => new S2SPeer {
Node = this
});
foreach (ActorDescription actorDesc in repository.ActorDescriptions)
{
Type coordinatorType = actorDesc.Attribute.Coordinator ?? DefaultActorCoordinator;
var actorCoord = (IActorCoordinator)Activator.CreateInstance(coordinatorType);
actorCoord.Init(this, actorDesc.PrimaryContract.TypeId);
_actorCoordinatorsByPrimaryContractId.Add(actorDesc.PrimaryContract.TypeId, actorCoord);
}
Fiber = new ServerFiber();
}
public HomeController(ILogger <HomeController> logger,
IActorRepository actor,
IUserRepository customer,
IMovieRepository movie,
IPast_PurchasesRepository past_purchase,
IPurchaseRepository purchase,
IRentalRepository rental,
IReviewRepository review,
ITransactionRepository transaction,
IAge_RatingRepository age_rating,
IDirectorRepository director,
IGenreRepository genre,
ICartRepository cart,
ITransactionDetailsRepository transactionDetails,
AppDbContext context
)
{
_logger = logger;
_actorList = actor;
_customerList = customer;
_movieList = movie;
_past_purchaseList = past_purchase;
_purchaseList = purchase;
_rentalList = rental;
_reviewList = review;
_transactionList = transaction;
_age_RatingList = age_rating;
_directorList = director;
_genreList = genre;
_cartList = cart;
_transactionDetailsList = transactionDetails;
_context = context;
}
public AddPage()
{
InitializeComponent();
actorRepository = Resolver.Resolve <IActorRepository>();
BindingContext = new Actor();
}
public MoviesController()
{
_context = new MovContext();
_producerRepository = new ProducerRepository(_context);
_actorRepository = new ActorRepository(_context);
_movieRepository = new MovieRepository(_context);
}
public Reviews(MovieList ml, int i)
{
actorRepo = new SqlActorRepository(connectionString);
movieRepo = new SqlMovieRepository(connectionString);
reviewRepo = new SqlReviewRepository(connectionString);
showtimeRepo = new SqlShowTimeRepository(connectionString);
ticketRepo = new SqlTicketRepository(connectionString);
viewerRepo = new SqlViewerRepository(connectionString);
InitializeComponent();
movieList = ml;
rUserLabel.Text = movieList.getCurrentUserLabel();
cu = movieList.getCurrentUser();
index = i;
movieName = movieRepo.FetchMovie(i).Name;
IReadOnlyList <Review> reviews = reviewRepo.FetchMovieReviews(i);
foreach (Review r in reviews)
{
listBox1.Items.Add(r.ToString());
}
movieNameLabel.Text = movieName;
}
/// <summary>
/// Constructor for retrieving the necessary services for the CRUD methods.
/// </summary>
/// <param name="actorRepository"></param>
/// <param name="movieRepository"></param>
/// <param name="mapper"></param>
/// <param name="linkGenerator"></param>
public ActorsController(IActorRepository actorRepository, IMovieRepository movieRepository, IMapper mapper, LinkGenerator linkGenerator)
{
_actorRepository = actorRepository;
_movieRepository = movieRepository;
_mapper = mapper;
_linkGenerator = linkGenerator;
}
public ActorController(AmidusDbContext context, IMapper mapper, IActorRepository repository, IUnitOfWork unitOfWork)
{
this.mapper = mapper;
this.context = context;
this.repository = repository;
this.unitOfWork = unitOfWork;
}
public MovieService(IMovieRepository movieRepository, IActorRepository actorRepository, IActorMovieRepository actorMovieRepository, IMovieGenreRepository movieGenreRepository)
{
_movieRepository = movieRepository;
_actorRepository = actorRepository;
_actorMovieRepository = actorMovieRepository;
_movieGenreRepository = movieGenreRepository;
}
public EFUnitOfWork(AEXTestDBContext context)
{
this.context = context;
MovieRepository = new MovieRepository(this.context);
ActorRepository = new ActorRepository(this.context);
GenreRepository = new GenreRepository(this.context);
}
//private readonly IActorMovieRepository _actorMovieRepository;
//private readonly IProducerMovieRepository _producerMovieRepository;
public MoviesController(IProducerRepository producerRepository, IMovieRepository movieRepository, IActorRepository actorRepository)
{
_movieRepository = movieRepository;
_actorRepository = actorRepository;
_producerRepository = producerRepository;
//_actorMovieRepository = actorMovieRepository;
//_producerMovieRepository = producerMovieRepository;
}
public ActorService(IActorRepository actorRepository, IMovieRepository movieRepository, IGradeRepository gradeRepository, IMovieActorRepository movieActorRepository, IMapper mapper)
{
_actorRepository = actorRepository;
_movieRepository = movieRepository;
_gradeRepository = gradeRepository;
_movieActorRepository = movieActorRepository;
_mapper = mapper;
}
public ActorsController(
IActorRepository actorRepository,
IMapper mapper,
IActionDescriptorCollectionProvider actionDescriptorCollectionProvider) : base(actionDescriptorCollectionProvider)
{
_actorRepository = actorRepository;
_mapper = mapper;
}
public MovieController(ILogger <MovieController> logger, IMovieRepository movieRepository, IActorRepository actorRepository, IMapper mapper)
{
_logger = logger;
//dependency injection
_movieRepository = movieRepository;
_actorRepository = actorRepository;
_mapper = mapper;
}
public ProducersController()
{
var context = new MovContext();
_producerRepository = new ProducerRepository(context);
_actorRepository = new ActorRepository(context);
_movieRepository = new MovieRepository(context);
}
public MovieService(IMovieRepository movieRepository, IActorRepository actorRepository, IMapper mapper, IActingRepository actingRepository, IRatingRepository ratingRepository)
{
_movieRepository = movieRepository;
_actorRepository = actorRepository;
_mapper = mapper;
_actingRepository = actingRepository;
_ratingRepository = ratingRepository;
}
public EditPage(Actor actor)
{
InitializeComponent();
Title = actor.Name;
actorRepository = Resolver.Resolve <IActorRepository>();
BindingContext = actor;
}
public SeriesServices(ISeriesRepository series, IActorRepository actorRepository,
IMapper mapper, ILogger <SeriesServices> logger)
{
this._actorRepository = actorRepository;
this._series = series;
this._mapper = mapper;
this._logger = logger;
}
protected override void EstablishContext()
{
base.EstablishContext();
_repository = new InMemoryActorRepository<RequestResponseActor>();
ObjectBuilder.Stub(x => x.GetInstance<ISagaRepository<RequestResponseActor>>())
.Return(_repository);
}
public HzgWebService()
{
this._IActorRepository = new ActorRepository();
this._IMovieRepository = new MovieRepository();
this._IGenreRepository = new GenreRepository();
this._IMediumTypeRepository = new MediumTypeRepository();
this._IActualValueAllgRepository = new ActualValueAllgRepository();
}
public UnitOfWork(
string actorType,
IActorRepository actorRepository,
INotificationRepository notificationRepository)
{
ActorType = actorType;
_actorRepository = actorRepository;
_notificationRepository = notificationRepository;
}
public MovieList()
{
actorRepo = new SqlActorRepository(connectionString);
movieRepo = new SqlMovieRepository(connectionString);
reviewRepo = new SqlReviewRepository(connectionString);
showtimeRepo = new SqlShowTimeRepository(connectionString);
ticketRepo = new SqlTicketRepository(connectionString);
viewerRepo = new SqlViewerRepository(connectionString);
}
public MovieService(IActorRepository actorRepository, IMovieRepository movieRepository, ICategoryRepository categoryRepository, IMovieActorRepository movieActorRepository, IMovieCategoryRepository movieCategoryRepository, IMapper mapper)
{
_actorRepository = actorRepository;
_movieRepository = movieRepository;
_categoryRepository = categoryRepository;
_movieActorRepository = movieActorRepository;
_movieCategoryRepository = movieCategoryRepository;
_mapper = mapper;
}
public Worker(ILogger <Worker> logger,
IConfiguration configuration,
IIMDBScraperService IMDBScraperService, IActorRepository actorRepository)
{
_logger = logger;
_configuration = configuration;
_IMDBScraperService = IMDBScraperService;
_actorRepository = actorRepository;
}
public ActorAppTests()
{
domainNotificationHandler = new DomainNotificationHandler();
this.subNotificationHandler = domainNotificationHandler;
this.subActorRepository = Substitute.For <IActorRepository>();
this.subUserRepository = Substitute.For <IUserRepository>();
this.subGenreRepository = Substitute.For <IGenreRepository>();
this.smartNotification = new SmartNotification(this.subNotificationHandler);
this.ActorAppServices = new ActorAppServices(this.smartNotification, this.subActorRepository, this.subUserRepository, this.subGenreRepository);
}
public MovieController(IMovieRepository movieRepository, IActorRepository actorRepository, ICompanyRepository companyRepository, IGenreRepository genreRepository, IMovieActorRepository movieActorRepository, IMovieCompanyRepository movieCompanyRepository, IMovieGenreRepository movieGenreRepository)
{
IMovieRepository = movieRepository;
IActorRepository = actorRepository;
ICompanyRepository = companyRepository;
IGenreRepository = genreRepository;
IMovieActorRepository = movieActorRepository;
IMovieCompanyRepository = movieCompanyRepository;
IMovieGenreRepository = movieGenreRepository;
}
public ActorAppServices(ISmartNotification notification,
IActorRepository actorRepositor,
IUserRepository userRepository,
IGenreRepository genreRepository)
{
_notification = notification;
_actorRepository = actorRepositor;
_userRepository = userRepository;
_genreRepository = genreRepository;
}
public loginForm(Form1 mf)
{
InitializeComponent();
mainForm = mf;
actorRepo = new SqlActorRepository(connectionString);
movieRepo = new SqlMovieRepository(connectionString);
reviewRepo = new SqlReviewRepository(connectionString);
showtimeRepo = new SqlShowTimeRepository(connectionString);
ticketRepo = new SqlTicketRepository(connectionString);
viewerRepo = new SqlViewerRepository(connectionString);
}
public ActorEventSubscriptionBehavior(IEnumerable<Type> eventTypes, IBus bus, IActorRepository repository)
{
_repository = repository;
foreach (var type in eventTypes)
{
bus.Subscribe(type, (Action<Object>)(x => EventHandler(x)), this, Priority.High);
}
bus.Subscribe(typeof(ActorCollidedEvent), (Action<Object>)(x => EventHandler(x)), this, Priority.High);
bus.Subscribe<ActorDestroyedEvent>(x => ActorDestroyed(x), this, Priority.High);
_bus = bus;
bus.Subscribe<ActorCreatedEvent>(x => ActorCreated(x), this);
}
public PhysicsActorBehavior(PhysicsSubsystem physicsSubsystem, IActorRepository actorRepository, IBus bus, IResourceDictionary resources, IEnumerable<Type> actorEventTypes)
{
_physicsSubsystem = physicsSubsystem;
_resources = resources;
_repository = actorRepository;
_actorMap = new Dictionary<Guid, IActorPhysics>();
bus.Subscribe<ActorCreatedEvent>(x => ActorCreated(x), this, Priority.Low);
bus.Subscribe<ActorDestroyedEvent>(x => ActorDestroyed(x), this, Priority.High);
bus.Subscribe<ActorPositionSetEvent>(x => SetPosition(x), this, Priority.High);
bus.Subscribe<ActorVelocitySetEvent>(x => SetVelocity(x), this, Priority.High);
bus.Subscribe<ForceAppliedToActorEvent>(x => ForceAppliedToActor(x), this, Priority.High);
foreach (var type in actorEventTypes)
{
bus.Subscribe(type, (Action<Object>)(x => EventHandler(x)), this, Priority.High);
}
}
void IGameSetters.SetRepository(IActorRepository actorRepository)
{
this.ActorRepository = actorRepository;
}
public FileImporterWithFactory(IActorRepository repository, IFileImporterFactory importerFactory)
{
this.repository = repository;
importer_factory = importerFactory;
}
public ActorService(IActorRepository actorRepository)
{
_actorRepository = actorRepository;
}
public MovieService(IMovieRepository movieRepository, IActorRepository actorRepository)
{
_movieRepository = movieRepository;
_actorRepository = actorRepository;
}
public RepositoryConsumer(IActorRepository actorRepository)
{
actor_repository = actorRepository;
}
public MoviesController(IMovieRepository repository, IActorRepository actorRepository)
{
_repository = repository;
_actorRepository = actorRepository;
}
public ActorsController(IActorRepository repository)
{
_repository = repository;
}