public BlokEmulationViewModel(IBlokEmitterFactory[] EmitterFactories, BlokEmulationParameters EmulationParameters, IMappingService MappingService) { _emitterFactories = EmitterFactories; ReactiveCommand<NavigationInformation> run = ReactiveCommand.CreateAsyncObservable( _ => EmulationParameters.WhenAnyValue(x => x.Position, x => x.Speed, (position, speed) => new { position, speed }) .CombineLatest(this.WhenAnyValue(x => x.Reliability), (n, r) => new NavigationInformation(n.position, n.speed, r)) .TakeUntil(_stop) .EmitThorough(SelectedEmitterFactory.CreatEmitter())); _stop = ReactiveCommand.Create(); Run = run; Stop = _stop; this.WhenAnyValue(x => x.EmulationEnabled) .Where(running => running) .InvokeCommand(Run); this.WhenAnyValue(x => x.EmulationEnabled) .Where(running => !running) .InvokeCommand(Stop); this.WhenAnyValue(x => x.EmulationEnabled) .Select(e => !e) .ToProperty(this, x => x.CanChangeEmissionMethod, out _canChangeEmissionMethod, true); SelectedEmitterFactory = EmitterFactories.First(); _positionPresenter = new PositionPresenter(MappingService, EmulationParameters.WhenAnyValue(x => x.Position)); }
public OrdersController( IQuartetClientFactory clientFactory, IMappingService<Order, OrderViewModel> orderMapping, IMappingService<Customer, HCardViewModel> hcardMapping, IMappingService<Address, AddressViewModel> addressMapping, IMailingService mailingService, IInvoicingService invoicingService, IFeaturesConfigService featuresConfigService, IAppSettings appSettings, IConsultantContext consultantContext, IConsultantDataServiceClientFactory consultantDataServiceClientFactory, IPromotionService promotionService, IProductCatalogClientFactory productCatalogClientFactory, IInventoryService inventoryService, ISubsidiaryAccessor subsidiaryAccessor ) { _clientFactory = clientFactory; _orderMapping = orderMapping; _hcardMapping = hcardMapping; _addressMapping = addressMapping; _mailingService = mailingService; _invoicingService = invoicingService; _featuresConfigService = featuresConfigService; _appSettings = appSettings; _consultantContext = consultantContext; _consultantDataServiceClientFactory = consultantDataServiceClientFactory; _promotionService = promotionService; _productCatalogClientFactory = productCatalogClientFactory; _inventoryService = inventoryService; _subsidiaryAccessor = subsidiaryAccessor; }
public ProfileController( IUsersService usersService, IMappingService mappingService) : base(usersService) { this.mappingService = mappingService; }
public TrackingControlViewModel(ITrackPresenter TrackPresenter, IMappingService MappingService, TrackFormatterManager TrackFormatterManager) { _trackPresenter = TrackPresenter; _trackFormatterManager = TrackFormatterManager; _mappingService = MappingService; _track = new ReactiveList<EarthPoint>(); _track.Changed .Subscribe(_ => RefreshTrack()); LoadTrack = ReactiveCommand.CreateAsyncTask(LoadTrackImpl); SaveTrack = ReactiveCommand.CreateAsyncTask(SaveTrackImpl); ReactiveCommand<object> clearCommand = ReactiveCommand.Create(_track.IsEmptyChanged.Select(e => !e)); clearCommand.Subscribe(_ => _track.Clear()); ClearTrack = clearCommand; IConnectableObservable<TrackPathRider> prp = _track.Changed .Select(_ => new TrackPathRider(new GpsTrack(_track.ToList()))) .Publish(); PathRider = prp; prp.Connect(); _mappingService.Clicks .Where(c => c.Action == MouseAction.LeftClick) .Subscribe(c => AppendPointToTrack(c.Point)); _mappingService.Clicks .Where(c => c.Action == MouseAction.RightClick) .Subscribe(c => _track.Remove(_track.LastOrDefault())); }
public ArticleFactory(IQueryRepository queryRepository, IValidator<Article> articleValidator, IValidator<Comment> commentValidator, IMappingService mappingService) { _queryRepository = queryRepository; _articleValidator = articleValidator; _commentValidator = commentValidator; _mappingService = mappingService; }
public ConfigurationService( IMappingService mapper ) { Mapper = mapper; Servers = new Lazy<IEnumerable<InternalCollectionServer>>(LoadCollectionServers); }
public TasksController( IQuartetClientFactory clientFactory, IMappingService<TaskListItem, TaskViewModel> taskMapping ) { _clientFactory = clientFactory; _taskMapping = taskMapping; }
public TaxaController( Lazy<ITaxa> Taxa, IMappingService Mapping ) : base(Mapping) { this._Taxa = Taxa; this.Mapping = Mapping; }
public MapLoaderControlViewModel(IMapLoadingService MapLoadingService, MapPresenter MapPresenter, IMappingService MappingService, ITrackSource TrackSource) { _mapLoadingService = MapLoadingService; _mapPresenter = MapPresenter; _mappingService = MappingService; _trackSource = TrackSource; _load = ReactiveCommand.CreateAsyncTask((_, c) => LoadMap()); }
public MappingUpdateViewModel( IEventAggregator eventAggregator, IRegionManager regionManager, IMappingService mappingService) { this.nexusId = this.NewMdmId(); this.eventAggregator = eventAggregator; this.regionManager = regionManager; this.mappingService = mappingService; }
public DashboardController( IQuartetClientFactory clientFactory, IAppSettings appSettings, IMappingService<NotificationCounts, DashboardViewModel> dashboardMapping ) { _clientFactory = clientFactory; _appSettings = appSettings; _dashboardMapping = dashboardMapping; }
public TaxonService( IMappingService Mapping, CollectionContext Collection, ApplicationUser user ) { this.Mapping = Mapping; this.Collection = Collection; this.User = user; }
public EditCustomerViewModel(ICustomerRepository customerRepository, IImageCaptureService imageCaptureService, IMappingService mappingService) { _customerRepository = customerRepository; _imageCaptureService = imageCaptureService; _mappingService = mappingService; CaptureImageCommand = new DelegateCommand(CaptureImage); OpenMapsCommand = new DelegateCommand(OpenMaps); SaveCustomerCommand = new DelegateCommand(SaveCustomer); }
public TasksController( IQuartetClientFactory clientFactory, IMappingService<TaskListItem, CustomerTaskContent> taskMapping, IConsultantContext consultantContext ) { _clientFactory = clientFactory; _taskMapping = taskMapping; _consultantContext = consultantContext; }
public SampleRequestController( IQuartetClientFactory clientFactory, IConsultantContext consultantContext, IMappingService<SampleRequest, SampleRequestViewModel> sampleRequestMappingService ) { _clientFactory = clientFactory; _consultantContext = consultantContext; _sampleRequestMappingService = sampleRequestMappingService; }
public ActivitySummaryController( IQuartetClientFactory quartetClientFactory, IConsultantContext consultantContext, IMappingService<TaskListItem, Activity> taskMapping ) { _quartetClientFactory = quartetClientFactory; _consultantContext = consultantContext; _taskMapping = taskMapping; }
public HomeController(IMappingService mappingService, IRestaurantTask restaurantTask, IRestaurantReviewTask restaurantReviewTask, IRestaurantRatingTask restaurantRatingTask, IRestaurantPhotoTask restaurantPhotoTask, ILookupTask lookupTask) { _mappingService = mappingService; _restaurantTask = restaurantTask; _restaurantReviewTask = restaurantReviewTask; _restaurantRatingTask = restaurantRatingTask; _restaurantPhotoTask = restaurantPhotoTask; _lookupTask = lookupTask; }
public FoodController(IFoodService foodService, IMappingService mappingService) { if (foodService == null) throw new ArgumentNullException("foodService"); if (mappingService == null) throw new ArgumentNullException("mappingService"); _foodService = foodService; _mappingService = mappingService; }
public ProductsController( IProductsService productsService, IIdentifierProvider identifierProvider, IVotesService votesService, IMappingService mappingService) { this.productsService = productsService; this.votesService = votesService; this.identifierProvider = identifierProvider; this.mappingService = mappingService; }
public CustomerNotesController( IQuartetClientFactory clientFactory, IConsultantContext consultantContext, IMappingService<Customer, CustomerDetailViewModel> customerMappingService, IImportCustomerService importCustomer ) { _clientFactory = clientFactory; _consultantContext = consultantContext; _customerMappingService = customerMappingService; _importCustomer = importCustomer; }
public MappingEditViewModel( IEventAggregator eventAggregator, IMappingService mappingService, IRegionManager regionManager, INavigationService navigationService) { this.eventAggregator = eventAggregator; this.mappingService = mappingService; this.regionManager = regionManager; this.navigationService = navigationService; this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>(); }
public MappingAddViewModel( IEventAggregator eventAggregator, IMappingService mappingService, INavigationService navigationService) { this.eventAggregator = eventAggregator; this.mappingService = mappingService; this.navigationService = navigationService; this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>(); this.SourceSystems = mappingService.GetSourceSystemNames().OrderBy(x => x).ToList(); this.SourceSystems.Insert(0, string.Empty); }
public OrdersController( IAppSettings appSettings, IProductCatalogClientFactory productCatalogClientFactory, IQuartetClientFactory clientFactory, IMappingService<Order, OrderViewModel> orderMapping, IFeaturesConfigService featuresConfigService ) { _appSettings = appSettings; _productCatalogClientFactory = productCatalogClientFactory; _clientFactory = clientFactory; _orderMapping = orderMapping; _featuresConfigService = featuresConfigService; }
public AccountController(IUserService userService, IMappingService mappingService, IAuthenticationService authenticationService) { if (userService == null) throw new ArgumentNullException("userService"); if (mappingService == null) throw new ArgumentNullException("mappingService"); if (authenticationService == null) throw new ArgumentNullException("authenticationService"); _userService = userService; _mappingService = mappingService; _authenticationService = authenticationService; }
public BrokerEditViewModel( IEventAggregator eventAggregator, IMdmService entityService, INavigationService navigationService, IMappingService mappingService, IApplicationCommands applicationCommands) { this.navigationService = navigationService; this.mappingService = mappingService; this.applicationCommands = applicationCommands; this.eventAggregator = eventAggregator; this.entityService = entityService; this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>(); this.CanEdit = AuthorisationHelpers.HasEntityRights("Broker"); }
public SourceSystemEditCloneViewModel( IEventAggregator eventAggregator, IMdmService entityService, INavigationService navigationService, IMappingService mappingService, IApplicationCommands applicationCommands) { this.navigationService = navigationService; this.mappingService = mappingService; this.applicationCommands = applicationCommands; this.eventAggregator = eventAggregator; this.entityService = entityService; this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>(); this.CanEdit = AuthorisationHelpers.HasEntityRights("SourceSystem"); this.eventAggregator.Subscribe<MappingClonedEvent>(this.MappingCloned); }
public CCPaymentController( IAppSettings appSettings, IProductCatalogClientFactory productCatalogClientFactory, IQuartetClientFactory clientFactory, IMappingService<Order, OrderViewModel> orderMapping, IFeaturesConfigService featuresConfigService, ICreditCardService creditCardService, IConsultantContext consultantContext ) { _appSettings = appSettings; _productCatalogClientFactory = productCatalogClientFactory; _clientFactory = clientFactory; _orderMapping = orderMapping; _featuresConfigService = featuresConfigService; _creditCardService = creditCardService; _consultantContext = consultantContext; }
public ImportCustomer( IConfigService configService, IQuartetClientFactory clientFactory, IAppSettings appSettings, IConsultantContext consultantContext, IMappingService<UploadedCustomer, ImportedCustomer> customerMappingService, IFacebookAuthentication fbAuth, IMailingService emailService ) { _configService = configService; _quartetClientFactory = clientFactory; _appSettings = appSettings; _consultantContext = consultantContext; _customerMappingService = customerMappingService; _fbAuth = fbAuth; _emailService = emailService; }
public LegalEntityEditViewModel( IEventAggregator eventAggregator, IMdmService entityService, INavigationService navigationService, IMappingService mappingService, IApplicationCommands applicationCommands, IList<string> partystatusConfiguration) { this.navigationService = navigationService; this.mappingService = mappingService; this.applicationCommands = applicationCommands; this.eventAggregator = eventAggregator; this.entityService = entityService; this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>(); this.CanEdit = AuthorisationHelpers.HasEntityRights("LegalEntity"); this.PartyStatusConfiguration = partystatusConfiguration; }
public SearchViewModel( IEventAggregator eventAggregator, IApplicationCommands applicationCommands, INavigationService navigationService, IMappingService mappingService) { this.eventAggregator = eventAggregator; this.applicationCommands = applicationCommands; this.navigationService = navigationService; this.mappingService = mappingService; this.MenuItems = new ObservableCollection<MenuItemViewModel>(); this.DisplayWelcome = true; this.AsOf = SystemTime.UtcNow().Date; this.SourceSystems = SourceSystemList(this.mappingService); this.SourceSystem = string.Empty; }
public UpdateBoardTaskCommandHandler(IDataContext dataContext, IMappingService mappingService) { this.dataContext = dataContext; this.mappingService = mappingService; }
public LoginService(IMappingService mapper, ILoginRepository loginRepository) : base(mapper) { this.loginRepository = loginRepository; }
public BookController(IMappingService _mappingService) { mappingService = _mappingService; }
public CreateCarCommand(CommandContext context, IService <Car> service, IValidator validation, IMappingService mapping) : base(context, validation) { this.service = service; this.mapping = mapping; }
public DomainMappingService(ILogger <MappingService <DomainDefinition, Domain> > logger, IMappingService <SchemaDefinition, Schema> mappingService) : base(logger) { Result = (input, parentId) => new Domain { SystemId = parentId, Name = new AsciiStringReference(input.Domain), Schemas = input.Schemas?.Select(s => mappingService.Map(s)).ToList() }; }
/// <summary> /// /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="searchCriteria"></param> /// <param name="page"></param> /// <param name="pageSize"></param> /// <param name="specification"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> /// <returns></returns> public AuditSearchVMDC SearchAudit(string currentUser, string user, string appID, string overrideID, AuditSearchCriteriaDC searchCriteria, int page, int pageSize, ISpecification <Audit> specification, IRepository <Audit> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == specification) { throw new ArgumentOutOfRangeException("specification"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { // Evaluate search criteria if supplied if (null != searchCriteria) { EvaluateSearchCriteria(searchCriteria, ref specification); } // Set default sort expression System.Linq.Expressions.Expression <Func <Audit, Object> > sortExpression = x => new { x.TypeOfObject }; // Find all items that satisfy the specification created above. IEnumerable <Audit> dataEntities = dataRepository.Find(specification, sortExpression, page, pageSize); // Get total count of items for search critera int itemCount = dataRepository.Count(specification); AuditSearchVMDC results = new AuditSearchVMDC(); // Convert to data contracts List <AuditSearchMatchDC> destinations = mappingService.Map <IEnumerable <Audit>, List <AuditSearchMatchDC> >(dataEntities); results.MatchList = destinations; results.SearchCriteria = searchCriteria; results.RecordCount = itemCount; return(results); } } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); return(null); } }
public SubmitWorkflow(ISubmitService submitService, IMappingService mappingService, ISessionHelper sessionHelper) { _submitService = submitService; _mappingService = mappingService; _sessionHelper = sessionHelper; }
public EfCourseRepository(StudentSystemDbContext studentSystemDbContext, IMappingService mapping) { _studentSystemDbContext = studentSystemDbContext; _mapping = mapping; }
/// <summary> /// Update a Audit /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="code"></param> /// <param name="lockID"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> public void DeleteAudit(string currentUser, string user, string appID, string overrideID, string code, string lockID, IRepository <Audit> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (string.IsNullOrEmpty(code)) { throw new ArgumentOutOfRangeException("code"); } if (string.IsNullOrEmpty(lockID)) { throw new ArgumentOutOfRangeException("lockID"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { // Convert string to guid Guid codeGuid = Guid.Parse(code); // Find item based on ID Audit dataEntity = dataRepository.Single(x => x.Code == codeGuid); // Delete the item dataRepository.Delete(dataEntity); // Commit unit of work uow.Commit(); } } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); } }
public StudentRegisterController(IRepositoryService repositoryService, IMappingService mappingService, ILoggingService loggingService) : base(repositoryService, mappingService, loggingService) { }
public HomeController(IPostService postService, IMappingService mappingService, IPaginator paginator) : base(mappingService) { this.postService = postService ?? throw new ArgumentNullException(); this.paginator = paginator ?? throw new ArgumentNullException(); }
public SourceTypeMapper(IMappingService service, IMappingServiceProvider serviceProvider) : base(service, serviceProvider) { }
public ServiceBase(IRequestContext requestContext) { context = requestContext; mappingService = context.Factory.GetService <IMappingService>(); }
public UserStore(IMappingService mappingService) { _mappingService = mappingService; }
public ToDoItemController(IMappingService <EntityDbContext> service, ITodoItemService todoItemService) { this.service = service; this.todoItemService = todoItemService; }
public MeetupService(IUnitOfWork unitOfWork, IMappingService mappingService) { _unitOfWork = unitOfWork; _mappingService = mappingService; }
/// <summary> /// /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="specification"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> /// <returns></returns> public List <AuditDC> GetAllAudit(string currentUser, string user, string appID, string overrideID, ISpecification <Audit> specification, IRepository <Audit> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == specification) { throw new ArgumentOutOfRangeException("specification"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { // Set default sort expression System.Linq.Expressions.Expression <Func <Audit, Object> > sortExpression = x => new { x.TypeOfObject }; // Find all items that satisfy the specification created above. IEnumerable <Audit> dataEntities = dataRepository.Find(specification, sortExpression); // Convert to data contracts List <AuditDC> destinations = mappingService.Map <IEnumerable <Audit>, List <AuditDC> >(dataEntities); return(destinations); } } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); return(null); } }
public EditCarExtraCommand(CommandContext context, IService <Extra> service, IValidator validation, IMappingService mapping) : base(context, validation) { this.service = service; this.mapping = mapping; }
public NominalService(IMappingService mapper, INominalRepository nominalRepository) : base(mapper) { this.nominalRepository = nominalRepository; }
/// <summary> /// Retrieve a Audit with associated lookups /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="code"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> /// <returns></returns> public AuditVMDC GetAudit(string currentUser, string user, string appID, string overrideID, string code, IUnitOfWork uow, IRepository <Audit> dataRepository , IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { AuditDC destination = null; // If code is null then just return supporting lists if (!string.IsNullOrEmpty(code)) { // Convert code to Guid Guid codeGuid = Guid.Parse(code); // Retrieve specific Audit Audit dataEntity = dataRepository.Single(x => x.Code == codeGuid); // Convert to data contract for passing through service interface destination = mappingService.Map <Audit, AuditDC>(dataEntity); } // Create aggregate contract AuditVMDC returnObject = new AuditVMDC(); returnObject.AuditItem = destination; return(returnObject); } } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); return(null); } }
public UserService(IMappingService mapper, IUserRepository userRepository) : base(mapper) { this.userRepository = userRepository; }
/// <summary> /// Create a Audit /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="dc"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> public AuditVMDC CreateAudit(string currentUser, string user, string appID, string overrideID, AuditDC dc, IRepository <Audit> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (null == dc) { throw new ArgumentOutOfRangeException("dc"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { // Create a new ID for the Audit item dc.Code = Guid.NewGuid(); // Map data contract to model Audit destination = mappingService.Map <AuditDC, Audit>(dc); // Add the new item dataRepository.Add(destination); // Commit unit of work uow.Commit(); // Map model back to data contract to return new row id. dc = mappingService.Map <Audit, AuditDC>(destination); } // Create aggregate data contract AuditVMDC returnObject = new AuditVMDC(); // Add new item to aggregate returnObject.AuditItem = dc; return(returnObject); } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); return(null); } }
public UserRepository(IMappingService mappingService, IUserService userService) { _mappingService = mappingService; _userService = userService; }
/// <summary> /// Update a Referrer /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="dc"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> public ReferrerVMDC UpdateReferrer(string currentUser, string user, string appID, string overrideID, ReferrerDC dc, IRepository <Referrer> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (null == dc) { throw new ArgumentOutOfRangeException("dc"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { // Map data contract to model Referrer destination = mappingService.Map <ReferrerDC, Referrer>(dc); // Add the new item dataRepository.Update(destination); // Commit unit of work uow.Commit(); // Map model back to data contract to return new row id. dc = mappingService.Map <Referrer, ReferrerDC>(destination); } // Create new data contract to return ReferrerVMDC returnObject = new ReferrerVMDC(); // Add new item to datacontract returnObject.ReferrerItem = dc; // Commit unit of work return(returnObject); } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); return(null); } }
public TicketController(IMappingService mappingService, ITicketService ticketService) : base(mappingService) { this.ticketService = ticketService; }
public CreateUserCommand(CommandContext context, IUserService service, IValidator validation, ICryptographyService cryptography, IMappingService mapping) : base(context, validation) { this.service = service; this.cryptography = cryptography; this.mapping = mapping; }
public AuthController(IRepositoryService repositoryService, IMappingService mappingService, ILoggingService loggingService) : base(repositoryService, mappingService, loggingService) { }
public CompetitionService(ICompetitionRepo competitionRepo, IChallengeRepo challengeRepo, IMappingService mappingService, IAdminRepo adminRepo, IParticipantRepo participantRepo) { _competitionRepo = competitionRepo; _challengeRepo = challengeRepo; _mappingService = mappingService; _adminRepo = adminRepo; _participantRepo = participantRepo; }
public TestSuiteController(ITestSuiteService testSuiteService, ITagsService tagsService, IMappingService mappingService, IPositionService positionService, IUserService userService, Silicus.UtilityContainer.Services.Interfaces.IUserService containerUserService, CommonController commonController) { _testSuiteService = testSuiteService; _tagsService = tagsService; _mappingService = mappingService; _positionService = positionService; _userService = userService; _containerUserService = containerUserService; _commonController = commonController; }
/// <summary> /// Retrieve a CustomerControlMeasure with associated lookups /// </summary> /// <param name="currentUser"></param> /// <param name="user"></param> /// <param name="appID"></param> /// <param name="overrideID"></param> /// <param name="code"></param> /// <param name="dataRepository"></param> /// <param name="uow"></param> /// <returns></returns> public CustomerControlMeasureVMDC GetCustomerControlMeasure(string currentUser, string user, string appID, string overrideID, string code, IUnitOfWork uow, IRepository <CustomerControlMeasure> dataRepository , IRepository <Customer> customerRepository , IRepository <ControlMeasure> controlMeasureRepository , IExceptionManager exceptionManager, IMappingService mappingService) { try { #region Parameter validation // Validate parameters if (string.IsNullOrEmpty(currentUser)) { throw new ArgumentOutOfRangeException("currentUser"); } if (string.IsNullOrEmpty(user)) { throw new ArgumentOutOfRangeException("user"); } if (string.IsNullOrEmpty(appID)) { throw new ArgumentOutOfRangeException("appID"); } if (null == dataRepository) { throw new ArgumentOutOfRangeException("dataRepository"); } if (null == uow) { throw new ArgumentOutOfRangeException("uow"); } if (null == exceptionManager) { throw new ArgumentOutOfRangeException("exceptionManager"); } if (null == mappingService) { throw new ArgumentOutOfRangeException("mappingService"); } #endregion using (uow) { CustomerControlMeasureDC destination = null; // If code is null then just return supporting lists if (!string.IsNullOrEmpty(code)) { // Convert code to Guid Guid codeGuid = Guid.Parse(code); // Retrieve specific CustomerControlMeasure CustomerControlMeasure dataEntity = dataRepository.Single(x => x.Code == codeGuid); // Convert to data contract for passing through service interface destination = mappingService.Map <CustomerControlMeasure, CustomerControlMeasureDC>(dataEntity); } IEnumerable <Customer> customerList = customerRepository.GetAll(x => new { x.Title }); IEnumerable <ControlMeasure> controlMeasureList = controlMeasureRepository.GetAll(x => new { x.ControlMeasureDescription }); List <CustomerDC> customerDestinationList = mappingService.Map <List <CustomerDC> >(customerList); List <ControlMeasureDC> controlMeasureDestinationList = mappingService.Map <List <ControlMeasureDC> >(controlMeasureList); // Create aggregate contract CustomerControlMeasureVMDC returnObject = new CustomerControlMeasureVMDC(); returnObject.CustomerControlMeasureItem = destination; returnObject.CustomerList = customerDestinationList; returnObject.ControlMeasureList = controlMeasureDestinationList; return(returnObject); } } catch (Exception e) { //Prevent exception from propogating across the service interface exceptionManager.ShieldException(e); return(null); } }