public int AddFowardingServer(IUnitOfWork uow, ForwardingServer forwardingServer)
 {
     var mappedForwardingServer = Mapper.Map<SQL.Models.ForwardingServer>(forwardingServer);
     var id = Convert.ToInt32(uow.Db.Insert(mappedForwardingServer));
     Mapper.Map(mappedForwardingServer, forwardingServer);
     return id;
 }

 public AircraftsController(
     IUnitOfWork unitOfWork,
     ILotRepository lotRepository,
     IInventoryRepository inventoryRepository,
     IAircraftRepository aircraftRepository,
     IAircraftRegistrationRepository aircraftRegistrationRepository,
     IAircraftRegMarkRepository aircraftRegMarkRepository,
     ISModeCodeRepository sModeCodeRepository,
     IFileRepository fileRepository,
     IApplicationRepository applicationRepository,
     ICaseTypeRepository caseTypeRepository,
     ILotEventDispatcher lotEventDispatcher,
     UserContext userContext)
 {
     this.unitOfWork = unitOfWork;
     this.lotRepository = lotRepository;
     this.inventoryRepository = inventoryRepository;
     this.aircraftRepository = aircraftRepository;
     this.aircraftRegistrationRepository = aircraftRegistrationRepository;
     this.aircraftRegMarkRepository = aircraftRegMarkRepository;
     this.sModeCodeRepository = sModeCodeRepository;
     this.fileRepository = fileRepository;
     this.applicationRepository = applicationRepository;
     this.caseTypeRepository = caseTypeRepository;
     this.lotEventDispatcher = lotEventDispatcher;
     this.userContext = userContext;
 }

 public ExternalAuthSettings(IUnitOfWork unitOfWork)
     : base(unitOfWork)
 {
     AutoRegisterEnabled = true;
     GoogleSystemEnable = true;
     FacebookSystemEnable = true;
 }

 public ThreadServices(
     IRepository<Thread> threadRepository,
     IRepository<ThreadView> threadViewRepository,
     IRepository<Post> postRepository,
     IRepository<User> userRepository,
     IRepository<ThreadViewStamp> threadViewStampRepository,
     IRepository<Subscription> subscriptionRepository,
     IRepository<Attachment> attachmentRepository,
     PollServices pollServices,
     FileServices fileServices,
     ParseServices parseServices,
     RoleServices roleServices,
     IUnitOfWork unitOfWork)
     : base(unitOfWork)
 {
     _threadRepository = threadRepository;
     _threadViewRepository = threadViewRepository;
     _postRepository = postRepository;
     _userRepository = userRepository;
     _threadViewStampRepository = threadViewStampRepository;
     _subscriptionRepository = subscriptionRepository;
     _attachmentRepository = attachmentRepository;
     _pollServices = pollServices;
     _fileServices = fileServices;
     _parseServices = parseServices;
     _roleServices = roleServices;
 }

 public PatientServiceTest()
 {
     patientRepository = Substitute.For<IPatientRepository>();
     unitOfWork = Substitute.For<IUnitOfWork>();
     validatorService = Substitute.For<IValidatorService>();
     patientService = new PatientService(patientRepository, unitOfWork, validatorService);
 }

        public void SetUp()
        {
            mocks = new MockRepository();
            instance = mocks.DynamicMock<IUnitOfWork>();

            store = new ThreadedUnitOfWorkStore();
        }

        public TagService(IUnitOfWork unitOfWork, ITagValidation tagValidation)
            : base(unitOfWork)
        {
            Guard.NotNull(tagValidation, "tagValidation");

            this._tagValidation = tagValidation;
        }

 //
 // GET: /Partnership/
 public PartnershipController(IUnitOfWork unitOfWork, PartnershipService partnershipService, StagedPartnershipService stagedPartnershipService, ChurchService churchService, PartnershipLogExcelFileHandler fileHandler) : base(unitOfWork)
 {
     _partnershipService = partnershipService;
     _stagedPartnershipService = stagedPartnershipService;
     _churchService = churchService;
     _fileHandler = fileHandler;
 }

        public virtual async Task<int> AddAsync(IUnitOfWork unitOfWork, List<IUser> entities,
            List<IUserRole> roles = null)
        {
            try
            {
                var result = 0;

                foreach (var entity in entities)
                {
                    result += await this.AddAsync(unitOfWork, entity);
                }

                if (roles != null)
                {
                    foreach (var role in roles)
                    {
                        result += await unitOfWork.AddAsync<UserRole>(
                            Mapper.Map<UserRole>(role));
                    }
                }
                return result;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

 public AulaService(IAulaRepository repoAula, IAlunoRepository repoAluno, ITurmaRepository repoTurma, IUnitOfWork unitOfWork)
 {
     _aulaRepository = repoAula;
     _alunoRepository = repoAluno;
     _turmaRepository = repoTurma;
     _unitOfWork = unitOfWork;
 }

 public Creator(IUnitOfWork unitOfWork, IRepository<Battle> repositoryOfBattle, IRepository<User> repositoryOfUser, IRepository<Team> repositoryOfTeam)
 {
     _unitOfWork = unitOfWork;
     _repositoryOfBattle = repositoryOfBattle;
     _repositoryOfUser = repositoryOfUser;
     _repositoryOfTeam = repositoryOfTeam;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="CmsMembershipProvider" /> class.
 /// </summary>
 /// <param name="userService">The user service.</param>
 /// <param name="authenticationService">The authentication service.</param>
 /// <param name="unitOfWork">The unit of work.</param>
 /// <param name="membershipName">Name of the membership.</param>
 internal CmsMembershipProvider(IUserService userService, IAuthenticationService authenticationService, IUnitOfWork unitOfWork, string membershipName)
 {
     this.authenticationService = authenticationService;
     this.userService = userService;
     this.unitOfWork = unitOfWork;
     this.membershipName = membershipName;
 }

 public CompositeEntitySeeder(IUnitOfWork unitOfWork
     , CoreSqlSeeder coreSqlSeeder
     //, LanguageEntitySeeder languageEntitySeeder
     , LanguageSqlSeeder languageSqlSeeder
     , PlaceByGeoPlanetEntitySeeder placeByGeoPlanetEntitySeeder
     , RoleEntitySeeder roleEntitySeeder
     , EstablishmentEntitySeeder establishmentEntitySeeder
     , EmailTemplateEntitySeeder emailTemplateEntitySeeder
     , PersonEntitySeeder personEntitySeeder
     , UserEntitySeeder userEntitySeeder
     , MemberEntitySeeder memberEntitySeeder
     , InstitutionalAgreementEntitySeeder institutionalAgreementEntitySeeder
     , InstitutionalAgreementSettingsEntitySeeder institutionalAgreementSettingsEntitySeeder
 )
 {
     _unitOfWork = unitOfWork;
     _coreSqlSeeder = coreSqlSeeder;
     _languageSqlSeeder = languageSqlSeeder;
     //_languageEntitySeeder = languageEntitySeeder;
     _placeByGeoPlanetEntitySeeder = placeByGeoPlanetEntitySeeder;
     _roleEntitySeeder = roleEntitySeeder;
     _establishmentEntitySeeder = establishmentEntitySeeder;
     _emailTemplateEntitySeeder = emailTemplateEntitySeeder;
     _personEntitySeeder = personEntitySeeder;
     _userEntitySeeder = userEntitySeeder;
     _memberEntitySeeder = memberEntitySeeder;
     _institutionalAgreementEntitySeeder = institutionalAgreementEntitySeeder;
     _institutionalAgreementSettingsEntitySeeder = institutionalAgreementSettingsEntitySeeder;
 }

        private static void SetCurrentUow(IUnitOfWork value, ILogger logger)
        {
            if (value == null)
            {
                ExitFromCurrentUowScope(logger);
                return;
            }

            var unitOfWorkKey = CallContext.LogicalGetData(ContextKey) as string;
            if (unitOfWorkKey != null)
            {
                IUnitOfWork outer;
                if (UnitOfWorkDictionary.TryGetValue(unitOfWorkKey, out outer))
                {
                    if (outer == value)
                    {
                        logger.Warn("Setting the same UOW to the CallContext, no need to set again!");
                        return;
                    }

                    value.Outer = outer;
                }
            }

            unitOfWorkKey = value.Id;
            if (!UnitOfWorkDictionary.TryAdd(unitOfWorkKey, value))
            {
                throw new AbpException("Can not set unit of work! UnitOfWorkDictionary.TryAdd returns false!");
            }

            logger.Debug("Entering a new UOW scope: " + unitOfWorkKey);
            CallContext.LogicalSetData(ContextKey, unitOfWorkKey);
        }

        public static string GenerateCodeId(string codeTypeId, IUnitOfWork context)
        {
            var codeIds = context.FindAll<Code>().Where(c => c.CodeTypeId == codeTypeId).OrderBy(f => f.CodeId).Select(ci => ci.CodeId).ToList();
            var lastCodeId = codeIds.Count > 0 ? codeIds.Last() : null;
            var IdCharCount = lastCodeId != null ? lastCodeId.Count() - 1 : 9;
            List<char> chars = codeTypeId.ToList();
            var charArray = chars.ToArray();
            var numberId = 0;

            if (lastCodeId != null)
            {
                numberId = int.Parse(lastCodeId.TrimStart(charArray));

                if (lastCodeId[3].ToString(CultureInfo.InvariantCulture) == "1")
                {
                    numberId++;
                }
            }

            var newId = codeTypeId + numberId.ToString(CultureInfo.InvariantCulture);

            var charCount = (codeTypeId + numberId.ToString(CultureInfo.InvariantCulture)).Count();

            if (charCount < IdCharCount)
            {
                newId = string.Format(codeTypeId + '1' + new string('0', IdCharCount - charCount) + numberId.ToString(CultureInfo.InvariantCulture));

            }

            return newId;
        }

 public MainService(IUnitOfWork uow, ILotRepository lotrepository, ICathegoryRepository cathegoryRepository, IImageRepository imageRepository)
 {
     this.uow = uow;
     this.lotRepository = lotrepository;
     this.cathegoryRepository = cathegoryRepository;
     this.imageRepository = imageRepository;
 }

 public CustomerService(
     IUnitOfWork unitOfWork, 
     ICustomerRepository customerRepository)
 {
     UnitOfWork = unitOfWork;
     _customerRepository = customerRepository;
 }

 public static IEnumerable<ArticleUnitViewModel> ArticleUnitViewModelList(IUnitOfWork uow, IEnumerable<Article> articles)
 {
     var votesList = HttpRuntime.Cache.Get("PopularArticlesAndVotes") as IDictionary<int, int>;
     if (votesList == null)
     {
         votesList = uow.ArticleRepository.GetPopularArticlesIdAndVotes();
         HttpRuntime.Cache["PopularArticlesAndVotes"] = votesList;
     }
     var newList = new List<ArticleUnitViewModel>();
     foreach (var item in articles)
     {
         newList.Add(new ArticleUnitViewModel
         {
             Id = item.Id,
             Title = item.Title,
             Description = item.Description,
             UserId = item.UserId,
             Username = item.User.UserName,
             Items = item.Items.Count,
             Tags = item.Tags,
             Votes = votesList.Where(x => x.Key == item.Id).Select(x => x.Value).FirstOrDefault()
         });
     }
     return newList;
 }

        public void Setup()
        {
            var container = SetupTest.Container;

            _usuarioRepository = container.Resolve<IUsuarioRepository>();
            _unitOfWork = container.Resolve<IUnitOfWork>();
        }

 public VideoService(
     IUnitOfWork unitOfWork,
     IVideoRepository videoRepository)
 {
     this._unitOfWork = unitOfWork;
     this._videoRepository = videoRepository;
 }