public ShapeProvider(Func<MessageInfo,bool> match, IServices services)
 {
     if (match == null)
       throw new ArgumentNullException("match");
     _match = match;
     _services = services;
 }

 public PlayPanel(Transform content, IServices services)
 {
     go = content.gameObject;
     levelsContent = getChild("Viewport/Content");
     this.services = services;
     createLevels();
 }

 public static string UploadFileToS3(IServices services, string fileName, Stream file, string folderName)
 {
     string s3FilePath = string.Empty;
     if (file != null)
     {
         byte[] bFile = null;
         MemoryStream memoryStream = new MemoryStream();
         try
         {
             file.CopyTo(memoryStream);
             bFile = memoryStream.ToArray();
             s3FilePath = services.Image.SaveImage(fileName, bFile, folderName);
         }
         catch (Exception ex)
         {
             Log.Error("FileHelper_UploadFileToS3_error: " + fileName, ex);
         }
         finally
         {
             memoryStream.Close();
             memoryStream.Dispose();
         }
     }
     file.Close();
     file.Dispose();
     return s3FilePath;
 }

        //
        // GET: /Account/Login
        public AccountController(IServices services, ISettings settings, IComponents components, IUserStore<ApplicationUser, Guid> userStore)
            : base(services, settings)
        {
            _userManager = new ApplicationUserManager(userStore, services, components);

            Mapper.CreateMap<ApplicationUser, UserDto>();
        }

 public ShopPanel(Transform content, IServices services)
 {
     go = content.gameObject;
     this.services = services;
     setReferences();
     createElements();
 }

 public void Setup(IServices services, IMetaModel metaModel, ILocalizer localizer) {
     this.services = services;
     this.metaModel = metaModel;
     this.localizer = localizer;
     TypeResolver.Reset();
     ListPropertyValues = GetListPropertyValues();
 }

 public TopPanelComponent(IServices services)
 {
     this.services = services;
     init();
     showYPosition = go.transform.localPosition.y;
     go.SetActive(false);
 }

 public ShopElement(Transform transform, IServices services, ShopModel model)
 {
     go = transform.gameObject;
     this.services = services;
     this.model = model;
     setReferences();
     setTexts();
 }

        //public static bool IsSpecialistStandardHour(int specialistID, DateTime startTime, DateTime endTime, IServices service)
        //{
        //    bool isStandardHour = false;
        //    isStandardHour = service.StandardHour.IsStandardHour(specialistID, startTime, endTime);
        //    return isStandardHour;
        //}
        /// <summary>
        /// calculate fee for customer and speclist when book time or reschedule
        /// </summary>
        /// <param name="specialistId"></param>
        /// <param name="IsSpecialist"></param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="service"></param>
        /// <param name="specializationId"></param>
        /// <returns></returns>
        public static decimal GetbookingRateByBookDate(Guid bookingId, UserDto specialist, bool IsSpecialist, DateTime startTime, DateTime endTime, IServices services)
        {
            decimal rate = 0;
            //TODO: will use function check standardhour when branch 226369 merged
            bool isStandardHour = services.Users.IsStandardHour(specialist.Id, startTime, endTime);

            return rate;
        }

 public ShipPanel(Transform content, IServices services)
 {
     go = content.gameObject;
     this.services = services;
     shipContent = getChild("Viewport/Content");
     infoContent = getChild("Panel/Text");
     setData();
 }

        public override void Load(IServices services)
        {
            System.Windows.Forms.Application.EnableVisualStyles();
            System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);

            AddShortcut(ModifierKeys.Control,                      Key.OemPlus, () => m_functions.AlignByKey());
            AddShortcut(ModifierKeys.Control | ModifierKeys.Shift, Key.OemPlus, () => m_functions.AlignByDialog());
            base.Load(services);
        }

        public IntegrationController(IUserStore<ApplicationUser,Guid> userStore, IAdminServices adminServices, IServices services, ISettings settings, IComponents components)
            : base(services, settings)
        {
            //if(!(settings.Environment == Environment.Integration || settings.Environment == Environment.Debug))
            //    throw new SecurityException();

            _adminServices = adminServices;
            _userManager = new ApplicationUserManager(userStore, services, components);
        }

		public void SetUp()
		{
			var logger = _repository.Stub<ILogger>();
			_mockServices = _repository.StrictMock<IServices>();
			_mockMetaModel = _repository.StrictMock<IMetaModel>();
			_mockQueryBuilder = _repository.StrictMock<IQueryBuilder>();

			_processor = new TestVersionOneProcessor(null, logger);
			_processor.ConnectTest(_mockServices, _mockMetaModel, _mockQueryBuilder);
		}

        protected ViewModelBase(IServices services)
        {
            Services = services;
            Log = Services.Log;

            if (!IsInDesignMode)
            {
                WireMessages();
            }
        }

 private ServicesProvider()
 {
     // Remove remoting version and change the standard IServices Implementation
     _iServices = new OnlineServiceProvider();
     /*
     if (TechnicalSettings.UseOnlineMode)
         _iServices = Remoting.GetInstance();
     else
         _iServices = new Standard();
      */
 }

        internal RequiredFieldsValidator(IMetaModel metaModel, IServices services, IDataLayerInternal dataLayer) {
            this.metaModel = metaModel;
            this.services = services;
            this.dataLayer = dataLayer;
            
            logger = dataLayer.Logger;

            requiredFieldsList.Add(Entity.TaskType, GetRequiredFields(Entity.TaskType));
            requiredFieldsList.Add(Entity.DefectType, GetRequiredFields(Entity.DefectType));
            requiredFieldsList.Add(Entity.StoryType, GetRequiredFields(Entity.StoryType));
            requiredFieldsList.Add(Entity.TestType, GetRequiredFields(Entity.TestType));
        }

        public static void CreateTransaction(BookingDto booking, decimal amount, bool minimumCharge, IServices Services)
        {
            try
            {
                UserDto user = Services.Users.GetUserById(booking.Customer.Id);
                if (user != null)
                {
                    InvoiceDto consultationInvoice;

                    switch (user.PaymentMethod)
                    {
                        case PaymentMethod.CreditCard:
                            PaymentResult result = new PaymentResult();
                            if (amount != 0)
                            {
                                result = Services.Payment.Transaction(user.Id.ToString(), amount);

                                if (result.Success)
                                {
                                    consultationInvoice = Services.Invoices.CreateConsultationInvoice(amount, booking.Id, minimumCharge, true, result.Transaction.Id);
                                }
                                else
                                {
                                    Log.Error("Transaction fail. Message: " + result.ErrorMessage + " UserId: " + user.Id);
                                    CreateUnsuccessInvoice(user, booking, Services, amount);
                                }
                            }
                            break;

                        case PaymentMethod.PrePayment:
                            user.PrePaymentAmount -= amount;

                            if (Services.Users.UpdateUserInfo(user))
                            {
                                consultationInvoice = Services.Invoices.CreateConsultationInvoice(amount, booking.Id, minimumCharge, true, null);
                            }
                            else
                            {
                                CreateUnsuccessInvoice(user, booking, Services, amount);
                            }
                            break;

                        default:
                            break;
                    }
                }
            }
            catch (Exception e)
            {
                Log.Error("Create new transaction with UserId: " + booking.Customer.Id + " BookingId: " + booking.Id, e);
            }
        }

        private string VoiceInConference = "man"; // Default value

        #endregion Fields

        #region Constructors

        public ConferenceController(IServices services)
        {
            Services = services;

            // Get setting for voice and language in conference
            var voiceConfig = Services.SystemConfig.GetByKey(ParamatricBusinessRules.VOICE_IN_CONFERENCE.ToString());
            var languageConfig = Services.SystemConfig.GetByKey(ParamatricBusinessRules.LANGUAGE_IN_CONFERENCE.ToString());
            if (voiceConfig != null && languageConfig != null)
            {
                VoiceInConference = voiceConfig.Value;
                LanguageInConference = languageConfig.Value;
            }
        }

    public void Init(IServices services)
    {
        services.EventService.AddListener<GameEndedEvent>(onGameEnded);
        pool.CreateEntity()
            .AddEventService(services.EventService)
            .AddUIFactoryService(services.UIFactoryService)
            .AddAnalyticsService(services.AnalyticsService)
            .AddTranslationService(services.TranslationService)
            .AddCanvas(services.ViewService.Canvas);

        systems.Initialize();
        services.Updateables.Add(this);
    }

 public Manager(V1Instance v1, ISmtpAdapter smtpAdapter, IUserDirectoryReader ldapreader) {
     _services = v1.Services;
     _model = v1.Model;
     _defaultRole = v1.DefaultRole;
     _smtpAdapter = smtpAdapter;
     _directoryReader = ldapreader;
 }