public static WorkgroupVendorViewModel Create(IRepositoryWithTypedId<Vendor, string> vendorRepository, WorkgroupVendor workgroupVendor = null, Vendor vendor = null, VendorAddress vendorAddress = null, bool? newVendor = null) { Check.Require(vendorRepository != null, "Repository must be supplied"); var addresses = vendor != null ? new MultiSelectList(vendor.VendorAddresses.Select(a => new { TypeCode = a.TypeCode, Name = string.Format("{0} ({1}, {2}, {3} {4})", a.Name, a.Line1, a.City, a.State, a.Zip) }).ToList(), "TypeCode", "Name") : new MultiSelectList(new List<VendorAddress>(), "TypeCode", "Name"); var viewModel = new WorkgroupVendorViewModel { WorkgroupVendor = workgroupVendor ?? new WorkgroupVendor(), Vendor = vendor, VendorAddress = vendorAddress, //Vendors = vendorRepository.Queryable.OrderBy(a => a.Name).ToList(), VendorAddresses = addresses, NewVendor = newVendor }; if(viewModel.WorkgroupVendor.VendorId != null && string.IsNullOrWhiteSpace(viewModel.WorkgroupVendor.Name)) { var locVendor = vendorRepository.Queryable.First(a => a.Id == viewModel.WorkgroupVendor.VendorId); if(locVendor != null) { viewModel.WorkgroupVendor.Name = locVendor.Name; } } return viewModel; }
public DevStudentService(IRepositoryWithTypedId<Student, Guid> studentRepository, IRepository<Ceremony> ceremonyRepository, IRepository<Registration> registrationRepository, IRepositoryWithTypedId<MajorCode, string> majorRepository) { _studentRepository = studentRepository; _ceremonyRepository = ceremonyRepository; _registrationRepository = registrationRepository; _majorRepository = majorRepository; }
public PublicController(IRepository<InformationRequest> informationRequestRepository, IRepositoryWithTypedId<SeminarRole, string> seminarRoleRepository, IRepository<CaseStudy> caseStudyRepository, INotificationService notificationService) { _informationRequestRepository = informationRequestRepository; _seminarRoleRepository = seminarRoleRepository; _caseStudyRepository = caseStudyRepository; _notificationService = notificationService; }
//, INotificationSender notificationSender) //private readonly INotificationSender _notificationSender; public SystemController(IIndexService indexService, IRepositoryFactory repositoryFactory, IRepositoryWithTypedId<EmailQueue, Guid> emailQueueRepository) { _indexService = indexService; _repositoryFactory = repositoryFactory; _emailQueueRepository = emailQueueRepository; //_notificationSender = notificationSender; }
public NotificationServiceTests() { EmailRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<EmailQueue, Guid>>(); EmailPreferenceRepository = MockRepository.GenerateStub < IRepositoryWithTypedId<EmailPreferences, string>>(); UserIdentity = MockRepository.GenerateStub<IUserIdentity>(); UserRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<User, string>>(); OrderStatusCodeRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<OrderStatusCode, string>>(); ServerLink = MockRepository.GenerateStub<IServerLink>(); QueryRepositoryFactory = MockRepository.GenerateStub<IQueryRepositoryFactory>(); RepositoryFactory = MockRepository.GenerateStub<IRepositoryFactory>(); RepositoryFactory.OrganizationRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<Organization, string>>(); AdminWorkgroupRepository = MockRepository.GenerateStub<IRepository<AdminWorkgroup>>(); QueryRepositoryFactory.AdminWorkgroupRepository = AdminWorkgroupRepository; WorkgroupRepository = MockRepository.GenerateStub<IRepository<Workgroup>>(); RepositoryFactory.WorkgroupRepository = WorkgroupRepository; NotificationService = new NotificationService(EmailRepository, EmailPreferenceRepository, UserRepository, OrderStatusCodeRepository, UserIdentity, ServerLink, QueryRepositoryFactory, RepositoryFactory); ServerLink.Expect(a => a.Address).Return("FakeHost").Repeat.Any(); ApprovalRepository = MockRepository.GenerateStub<IRepository<Approval>>(); SetupOrderStatusCodes(); }
public EmailQueueController(IRepository<EmailQueue> emailQueueRepository, IRepositoryWithTypedId<Student, Guid> studentRepository , ICeremonyService ceremonyService, ILetterGenerator letterGenerator) { _emailQueueRepository = emailQueueRepository; _studentRepository = studentRepository; _ceremonyService = ceremonyService; _letterGenerator = letterGenerator; }
public WorkgroupServiceTests() { AutomapperConfig.Configure(); VendorRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<Vendor, string>>(); VendorAddressRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<VendorAddress, Guid>>(); UserRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<User, string>>(); EmailPreferencesRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<EmailPreferences, string>>(); WorkgroupPermissionRepository = MockRepository.GenerateStub<IRepository<WorkgroupPermission>>(); WorkgroupRepository = MockRepository.GenerateStub<IRepository<Workgroup>>(); OrganizationRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<Organization, string>>(); SearchService = MockRepository.GenerateStub<IDirectorySearchService>(); RepositoryFactory = MockRepository.GenerateStub<IRepositoryFactory>(); RepositoryFactory.RoleRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<Role, string>>(); RepositoryFactory.WorkgroupPermissionRepository = WorkgroupPermissionRepository; RepositoryFactory.AccountRepository = MockRepository.GenerateStub<IRepositoryWithTypedId<Account, string>>(); QueryRepositoryFactory = MockRepository.GenerateStub<IQueryRepositoryFactory>(); UserIdentity = MockRepository.GenerateStub<IUserIdentity>(); QueryRepositoryFactory.RelatatedWorkgroupsRepository = MockRepository.GenerateStub<IRepository<RelatedWorkgroups>>(); WorkgroupService = new WorkgroupService(VendorRepository, VendorAddressRepository, UserRepository, EmailPreferencesRepository, WorkgroupPermissionRepository, WorkgroupRepository, OrganizationRepository, SearchService, RepositoryFactory, QueryRepositoryFactory, UserIdentity); }
public static void FakeCollege(int count, IRepositoryWithTypedId<College, string> repository, List<College> specificColleges) { var colleges = new List<College>(); var specificTransactionsCount = 0; if (specificColleges != null) { specificTransactionsCount = specificColleges.Count; for (int i = 0; i < specificTransactionsCount; i++) { colleges.Add(specificColleges[i]); } } for (int i = 0; i < count; i++) { colleges.Add(CreateValidEntities.College(i + specificTransactionsCount + 1)); } var totalCount = colleges.Count; for (int i = 0; i < totalCount; i++) { colleges[i].SetIdTo((i + 1).ToString()); int i1 = i; repository .Expect(a => a.GetNullableById((i1 + 1).ToString())) .Return(colleges[i]) .Repeat .Any(); } repository.Expect(a => a.GetNullableById((totalCount + 1).ToString())).Return(null).Repeat.Any(); repository.Expect(a => a.Queryable).Return(colleges.AsQueryable()).Repeat.Any(); repository.Expect(a => a.GetAll()).Return(colleges).Repeat.Any(); }
public CaseStudyController(IRepository<CaseStudy> casestudyRepository, IRepository<Seminar> seminarRepository, IRepositoryWithTypedId<User, Guid> userRepository, IRepository<SeminarPerson> seminarPersonRepository, IPersonService personService) { _casestudyRepository = casestudyRepository; _seminarRepository = seminarRepository; _userRepository = userRepository; _seminarPersonRepository = seminarPersonRepository; _personService = personService; }
public static AddMajorCodeViewModel Create(IRepositoryWithTypedId<MajorCode, string> majorRepository, MajorCode majorCode) { Check.Require(majorRepository != null, "Repository is required."); var viewModel = new AddMajorCodeViewModel() {MajorCodes = majorRepository.GetAll("Id", true), MajorCode = majorCode, NewMajor = false}; return viewModel; }
public DepartmentalAdminRequestController(IRepositoryWithTypedId<DepartmentalAdminRequest, string> departmentalAdminRequestRepository, IRepositoryFactory repositoryFactory, IQueryRepositoryFactory queryRepositoryFactory, IDirectorySearchService directorySearchService, IUserIdentity userIdentity) { _departmentalAdminRequestRepository = departmentalAdminRequestRepository; _repositoryFactory = repositoryFactory; _queryRepositoryFactory = queryRepositoryFactory; _directorySearchService = directorySearchService; _userIdentity = userIdentity; }
public static MajorCodeViewModel Create(IRepositoryWithTypedId<MajorCode, string> majorRepository, IRepositoryWithTypedId<College, string> collegeRepository) { Check.Require(majorRepository != null, "majorRepository is required."); Check.Require(collegeRepository != null, "collegeRepository is required."); var viewModel = new MajorCodeViewModel() {MajorCodes = majorRepository.GetAll("Id", true), Colleges = collegeRepository.GetAll()}; return viewModel; }
public CeremonyController(IRepositoryWithTypedId<TermCode, string> termRepository, IRepositoryWithTypedId<vTermCode, string> vTermRepository, IRepositoryWithTypedId<College, string> collegeRepository, IMajorService majorService, ICeremonyService ceremonyService, IUserService userService) { _termRepository = termRepository; _vTermRepository = vTermRepository; _collegeRepository = collegeRepository; _majorService = majorService; _ceremonyService = ceremonyService; _userService = userService; }
public NamSearchController(IRepositoryWithTypedId<Vlan, int> vlanRepository, IRepositoryWithTypedId<DataNam, int> dataNamRepository, IRepositoryWithTypedId<Building, int> buildingRepository, IRepositoryWithTypedId<Department, string> departmentRepository ) { _vlanRepository = vlanRepository; _dataNamRepository = dataNamRepository; _buildingRepository = buildingRepository; _departmentRepository = departmentRepository; }
public InformationRequestController(IRepository<InformationRequest> informationrequestRepository, IRepository<InformationRequestNote> informationRequestNoteRepository, IRepositoryWithTypedId<AddressType, char> addressTypeRepository, IFirmService firmService, IRepository<User> userRepository, IRepository<Person> personRepository ) { _informationrequestRepository = informationrequestRepository; _informationRequestNoteRepository = informationRequestNoteRepository; _addressTypeRepository = addressTypeRepository; _firmService = firmService; _userRepository = userRepository; _personRepository = personRepository; _membershipService = new AccountMembershipService(); }
/* strings to be used in the messages */ //private const string ApprovalMessage = "Order request {0} for {1} has been approved by {2} at {3} review."; //private const string CancellationMessage = "Order request {0} for {1} has been cancelled by {2} at {3} review with the following comment \"{4}\"."; //private const string UpdateInKualiMessage = "Order request {0} for {1} has been updated in Kuali to {2}."; //private const string ChangeMessage = "Order request {0} for {1} has been changed by {2}."; //private const string SubmissionMessage = "Order request {0} for {1} has been submitted."; //private const string ArrivalMessage = "Order request {0} for {1} has arrived at your level ({2}) for review from {3}{4}."; //private const string CompleteMessage = "Order request {0} for {1} has been completed by {2}. Order will be completed as a {3}."; //private const string ReceiveMessage = "Order request {0} for {1} has {2} item(s) received."; //private const string RerouteMessage = "Order request {0} for {1} has been rerouted to you."; //private const string AddAttachmentMessage = "Order request {0} for {1} has a new attachment added by {2}"; //private const string AddNoteMessage = "Order request {0} for {1} has a new note added by {2}"; public NotificationService(IRepositoryWithTypedId<EmailQueue, Guid> emailRepository, IRepositoryWithTypedId<EmailPreferences, string> emailPreferenceRepository, IRepositoryWithTypedId<User, string> userRepository, IRepositoryWithTypedId<OrderStatusCode, string> orderStatusCodeRepository, IUserIdentity userIdentity, IServerLink serverLink, IQueryRepositoryFactory queryRepositoryFactory, IRepositoryFactory repositoryFactory ) { _emailRepository = emailRepository; _emailPreferenceRepository = emailPreferenceRepository; _userRepository = userRepository; _orderStatusCodeRepository = orderStatusCodeRepository; _userIdentity = userIdentity; _serverLink = serverLink; //_serverLink = "prepurchasing.ucdavis.edu"; _queryRepositoryFactory = queryRepositoryFactory; _repositoryFactory = repositoryFactory; }
public AttendeeController(IRepository<Seminar> seminarRespository, IRepositoryWithTypedId<User, Guid> userRepository, IRepository<SeminarPerson> seminarPersonRepository , IRepository<Person> personRepository, IRepository<Firm> firmRepository , IPersonService personService, IRegistrationService registrationService, IFirmService firmService, Agribusiness.Web.Services.INotificationService notificationService) { _seminarRespository = seminarRespository; _userRepository = userRepository; _seminarPersonRepository = seminarPersonRepository; _personRepository = personRepository; _firmRepository = firmRepository; _personService = personService; _registrationService = registrationService; _firmService = firmService; _notificationService = notificationService; }
public PersonService(IRepository<Firm> firmRepository, IRepository<Person> personRepository, IRepository<SeminarPerson> seminarPersonRepository, IRepository<Seminar> seminarRepository, IRepositoryWithTypedId<User, Guid> userRepository, IFirmService firmService, IRepositoryWithTypedId<AddressType, char> addressTypeRepository, IRepositoryWithTypedId<ContactType, char> contactTypeRepository, IRepository<Commodity> commodityRepository ) { _firmRepository = firmRepository; _personRepository = personRepository; _seminarPersonRepository = seminarPersonRepository; _seminarRepository = seminarRepository; _userRepository = userRepository; _firmService = firmService; _addressTypeRepository = addressTypeRepository; _contactTypeRepository = contactTypeRepository; _commodityRepository = commodityRepository; _membershipService = new AccountMembershipService(); }
public AdminController(IRepositoryWithTypedId<Student, Guid> studentRepository, IRepositoryWithTypedId<MajorCode, string> majorRepository, IStudentService studentService, IEmailService emailService, IMajorService majorService, ICeremonyService ceremonyService, IRegistrationService registrationService, IRegistrationPopulator registrationPopulator, IRepository<Registration> registrationRepository, IErrorService errorService, IReportService reportService) { if (emailService == null) throw new ArgumentNullException("emailService"); _studentRepository = studentRepository; _majorRepository = majorRepository; _studentService = studentService; _emailService = emailService; _majorService = majorService; _ceremonyService = ceremonyService; _registrationService = registrationService; _registrationPopulator = registrationPopulator; _registrationRepository = registrationRepository; _errorService = errorService; _reportService = reportService; }
public FileService(IRepositoryWithTypedId<Attachment, Guid> attachmentRepository) { _attachmentRepository = attachmentRepository; var storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", CloudConfigurationManager.GetSetting("AzureStorageAccountName"), CloudConfigurationManager.GetSetting("AzureStorageKey")); var storageAccount = CloudStorageAccount.Parse(storageConnectionString); var blobClient = storageAccount.CreateCloudBlobClient(); _container = blobClient.GetContainerReference("oppattachments"); _container.CreateIfNotExists(); _container.SetPermissions(new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off}); }
public static HomeViewModel Create(IRepositoryWithTypedId<Site, string> siteRepository, Site site) { var viewModel = new HomeViewModel() { Site = site }; if (site == null) { viewModel.Sites = siteRepository.Queryable.Where(a => a.IsActive).ToList(); } else { // load the current seminar viewModel.Seminar = SiteService.GetLatestSeminar(site.Id); } return viewModel; }
public PersonController(IRepository<Person> personRepository, IRepositoryWithTypedId<User, Guid> userRepository, IRepositoryWithTypedId<SeminarRole, string> seminarRoleRepository , IRepository<SeminarPerson> seminarPersonRepository, IRepository<Seminar> seminarRepository, IRepositoryWithTypedId<Agribusiness.Core.Domain.Membership, Guid> membershipRepository , IPictureService pictureService, IPersonService personService, IFirmService firmService, IRegistrationService registrationService , IvCardService vCardService,IEventService eventService, IRepositoryFactory repositoryFactory) { _personRepository = personRepository; _userRepository = userRepository; _seminarRoleRepository = seminarRoleRepository; _seminarPersonRepository = seminarPersonRepository; _seminarRepository = seminarRepository; _membershipRepository = membershipRepository; _pictureService = pictureService; _personService = personService; _firmService = firmService; _registrationService = registrationService; _vCardService = vCardService; _eventService = eventService; _repositoryFactory = repositoryFactory; _membershipService = new AccountMembershipService(); }
public WorkgroupService(IRepositoryWithTypedId<Vendor, string> vendorRepository, IRepositoryWithTypedId<VendorAddress, Guid> vendorAddressRepository, IRepositoryWithTypedId<User, string> userRepository, IRepositoryWithTypedId<EmailPreferences, string> emailPreferencesRepository, IRepository<WorkgroupPermission> workgroupPermissionRepository, IRepository<Workgroup> workgroupRepository, IRepositoryWithTypedId<Organization, string> organizationRepository, IDirectorySearchService searchService, IRepositoryFactory repositoryFactory, IQueryRepositoryFactory queryRepositoryFactory, IUserIdentity userIdentity) { _vendorRepository = vendorRepository; _vendorAddressRepository = vendorAddressRepository; _userRepository = userRepository; _emailPreferencesRepository = emailPreferencesRepository; _workgroupPermissionRepository = workgroupPermissionRepository; _workgroupRepository = workgroupRepository; _organizationRepository = organizationRepository; _searchService = searchService; _repositoryFactory = repositoryFactory; _queryRepositoryFactory = queryRepositoryFactory; _userIdentity = userIdentity; }
public StudentController(IStudentService studentService, IEmailService emailService, IRepositoryWithTypedId<Student, Guid> studentRepository, IRepository<Ceremony> ceremonyRepository, IRepository<Registration> registrationRepository, IErrorService errorService, ICeremonyService ceremonyService, IReportService reportService, IRepository<RegistrationPetition> registrationPetitionRepository, IRepository<RegistrationParticipation> participationRepository, IRegistrationPopulator registrationPopulator) { _studentRepository = studentRepository; _ceremonyRepository = ceremonyRepository; _registrationRepository = registrationRepository; _errorService = errorService; _ceremonyService = ceremonyService; _reportService = reportService; _registrationPetitionRepository = registrationPetitionRepository; _participationRepository = participationRepository; _registrationPopulator = registrationPopulator; _studentService = studentService; _emailService = emailService; }
public MomoLandingViewComponent(IRepositoryWithTypedId <PaymentProvider, string> paymentProviderRepository) { _paymentProviderRepository = paymentProviderRepository; }
public FakeVendorAddresses(int count, IRepositoryWithTypedId <VendorAddress, Guid> repository, List <VendorAddress> specificRecords, bool bypassSetIdTo) { Records(count, repository, specificRecords, bypassSetIdTo); }
public FakeAccounts(int count, IRepositoryWithTypedId <Account, string> repository) { Records(count, repository, false); }
/// <summary> /// Initializes a new instance of the <see cref="WorkgroupAccountRepositoryTests"/> class. /// </summary> public WorkgroupAccountRepositoryTests() { WorkgroupAccountRepository = new Repository <WorkgroupAccount>(); AccountRepository = new RepositoryWithTypedId <Account, string>(); UserRepository = new RepositoryWithTypedId <User, string>(); }
public FakeCommentHistory(int count, IRepositoryWithTypedId <CommentHistory, Guid> repository, List <CommentHistory> specificRecords, bool bypassSetIdTo) { Records(count, repository, specificRecords, bypassSetIdTo); }
public FakeAttachments(int count, IRepositoryWithTypedId <Attachment, Guid> repository, List <Attachment> specificRecords, bool bypassSetIdTo, bool useSpecificGuids = false) { Records(count, repository, specificRecords, bypassSetIdTo, useSpecificGuids); }
public CountryApiController(IRepositoryWithTypedId <Country, string> countryRepository) { _countryRepository = countryRepository; }
public StateOrProvinceApiController(IRepository <StateOrProvince> stateOrProvinceRepository, IRepositoryWithTypedId <Country, string> countryRepository) { _stateOrProvinceRepository = stateOrProvinceRepository; _countryRepository = countryRepository; }
public static void FakeMajors(int count, IRepositoryWithTypedId<MajorCode, string> majorRepository) { var majorCodes = new List<MajorCode>(); FakeMajors(count, majorRepository, majorCodes); }
public FakeEmailPreferences(int count, IRepositoryWithTypedId <EmailPreferences, string> repository) { Records(count, repository, false); }
public FakeEmailPreferences(int count, IRepositoryWithTypedId <EmailPreferences, string> repository, List <EmailPreferences> specificRecords, bool bypassSetIdTo) { Records(count, repository, specificRecords, bypassSetIdTo); }
public AppSettingApiController(IRepositoryWithTypedId <AppSetting, string> appSettingRepository, IConfiguration configuration) { _appSettingRepository = appSettingRepository; _configurationRoot = (IConfigurationRoot)configuration; }
public FakeSubAccounts(int count, IRepositoryWithTypedId <SubAccount, Guid> repository) { Records(count, repository, false); }
public FakeSubAccounts(int count, IRepositoryWithTypedId <SubAccount, Guid> repository, List <SubAccount> specificRecords, bool bypassSetIdTo) { Records(count, repository, specificRecords, bypassSetIdTo); }
/// <summary> /// Initializes a new instance of the <see cref="BuildingRepositoryTests"/> class. /// </summary> public BuildingRepositoryTests() { BuildingRepository = new RepositoryWithTypedId <Building, string>(); }
/// <summary> /// Fakes the student. Note: Using more than 20 will not be reliable /// because the Guids will be random /// </summary> /// <param name="count">The count.</param> /// <param name="studentRepository">The student repository.</param> /// <param name="studentRepository2">The student repository2.</param> public static void FakeStudent(int count, IRepositoryWithTypedId<Student, Guid> studentRepository, IRepository<Student> studentRepository2) { var students = new List<Student>(); FakeStudent(count, studentRepository, students, studentRepository2); }
public FakeAttachments(int count, IRepositoryWithTypedId <Attachment, Guid> repository) { Records(count, repository, false); }
public static void FakeCollege(int count, IRepositoryWithTypedId<College, string> repository) { var colleges = new List<College>(); FakeCollege(count, repository, colleges); }
public ShippingProviderApiController(IRepositoryWithTypedId <ShippingProvider, string> shippingProviderRepositor) { _shippingProviderRepositor = shippingProviderRepositor; }
public FakeVendors(int count, IRepositoryWithTypedId <Vendor, string> repository) { Records(count, repository, false); }
public FakeCommentHistory(int count, IRepositoryWithTypedId <CommentHistory, Guid> repository) { Records(count, repository, false); }
public WidgetInstanceApiController(IRepository <WidgetInstance> widgetInstanceRepository, IRepositoryWithTypedId <Widget, string> widgetRespository) { _widgetInstanceRepository = widgetInstanceRepository; _widgetRespository = widgetRespository; }
public NganLuongApiController(IRepositoryWithTypedId <PaymentProvider, string> paymentProviderRepository) { _paymentProviderRepository = paymentProviderRepository; }
public FakeVendors(int count, IRepositoryWithTypedId <Vendor, string> repository, List <Vendor> specificRecords, bool bypassSetIdTo) { Records(count, repository, specificRecords, bypassSetIdTo); }
public FakeVendorAddresses(int count, IRepositoryWithTypedId <VendorAddress, Guid> repository) { Records(count, repository, false); }
public UserAddressController(IRepository <UserAddress> userAddressRepository, IRepositoryWithTypedId <Country, string> countryRepository, IRepository <StateOrProvince> stateOrProvinceRepository, IRepository <District> districtRepository, IRepository <User> userRepository, IWorkContext workContext) { _userAddressRepository = userAddressRepository; _countryRepository = countryRepository; _stateOrProvinceRepository = stateOrProvinceRepository; _districtRepository = districtRepository; _userRepository = userRepository; _workContext = workContext; }
public AutoApprovalController(IRepository <AutoApproval> autoApprovalRepository, IRepositoryWithTypedId <User, string> userRepository) { _autoApprovalRepository = autoApprovalRepository; _userRepository = userRepository; }
public FakeAccounts(int count, IRepositoryWithTypedId <Account, string> repository, List <Account> specificRecords, bool bypassSetIdTo) { Records(count, repository, specificRecords, bypassSetIdTo); }
public static void FakeMajors(int count, IRepositoryWithTypedId<MajorCode, string> majorRepository, List<MajorCode> specificMajorCodes) { var majorCodes = new List<MajorCode>(); var specificMajorCodesCount = 0; if (specificMajorCodes != null) { specificMajorCodesCount = specificMajorCodes.Count; for (int i = 0; i < specificMajorCodesCount; i++) { majorCodes.Add(specificMajorCodes[i]); } } for (int i = 0; i < count; i++) { majorCodes.Add(CreateValidEntities.MajorCode(i + specificMajorCodesCount + 1)); } var totalCount = majorCodes.Count; for (int i = 0; i < totalCount; i++) { majorCodes[i].SetIdTo((i + 1).ToString()); int i1 = i; majorRepository .Expect(a => a.GetNullableById((i1 + 1).ToString())) .Return(majorCodes[i]) .Repeat .Any(); } majorRepository.Expect(a => a.GetNullableById((totalCount + 1).ToString())).Return(null).Repeat.Any(); majorRepository.Expect(a => a.Queryable).Return(majorCodes.AsQueryable()).Repeat.Any(); majorRepository.Expect(a => a.GetAll()).Return(majorCodes).Repeat.Any(); }
public StripeLandingViewComponent(ICartService cartService, IWorkContext workContext, IRepositoryWithTypedId <PaymentProvider, string> paymentProviderRepository) { _cartService = cartService; _workContext = workContext; _paymentProviderRepository = paymentProviderRepository; }
/// <summary> /// Fakes the student. Note: Using more than 20 will not be reliable /// because the Guids will be random /// </summary> /// <param name="count">The count.</param> /// <param name="studentRepository">The student repository.</param> /// <param name="specificStudents">The specific students.</param> /// <param name="studentRepository2">The student repository2.</param> public static void FakeStudent(int count, IRepositoryWithTypedId<Student, Guid> studentRepository, List<Student> specificStudents, IRepository<Student> studentRepository2) { var students = new List<Student>(); var specificStudentsCount = 0; if (specificStudents != null) { specificStudentsCount = specificStudents.Count; for (int i = 0; i < specificStudentsCount; i++) { students.Add(specificStudents[i]); } } for (int i = 0; i < count; i++) { students.Add(CreateValidEntities.Student(i + specificStudentsCount + 1)); } var totalCount = students.Count; for (int i = 0; i < totalCount; i++) { students[i].SetIdTo(SpecificGuid.GetGuid(i+1)); int i1 = i; studentRepository .Expect(a => a.GetNullableById(students[i1].Id)) .Return(students[i]) .Repeat .Any(); } studentRepository.Expect(a => a.GetNullableById(SpecificGuid.GetGuid(totalCount + 1))).Return(null).Repeat.Any(); studentRepository.Expect(a => a.Queryable).Return(students.AsQueryable()).Repeat.Any(); studentRepository.Expect(a => a.GetAll()).Return(students).Repeat.Any(); if(studentRepository2 != null) { studentRepository2.Expect(a => a.Queryable).Return(students.AsQueryable()).Repeat.Any(); studentRepository2.Expect(a => a.GetAll()).Return(students).Repeat.Any(); } }
public DirectorySearchController(IDirectorySearchService directorySearchService, IRepositoryWithTypedId <User, string> userRepository) { _directorySearchService = directorySearchService; _userRepository = userRepository; }
public AccountController(IRepositoryWithTypedId <User, Guid> userRepository, IRepositoryWithTypedId <Agribusiness.Core.Domain.Membership, Guid> membershipRepository) { _userRepository = userRepository; _membershipRepository = membershipRepository; }
public LocalizationApiController(IStringLocalizerFactory stringLocalizerFactory, IRepository <Resource> resourceRepository, IRepositoryWithTypedId <Culture, string> cultureRepository) { _localizer = stringLocalizerFactory.Create(null); _resourceRepository = resourceRepository; _cultureRepository = cultureRepository; }
public TemplateController(IRepository<Template> templateRepository, IRepositoryWithTypedId<NotificationType, string> notificationTypeRepository) { _templateRepository = templateRepository; _notificationTypeRepository = notificationTypeRepository; }
public LocalizationController(IRepositoryWithTypedId <User, long> userRepository, IWorkContext workContext) { _userRepository = userRepository; _workContext = workContext; }