/// <summary>
        /// using Microsoft.Extensions.DependencyInjection;
        /// </summary>
        /// <returns></returns>
        public IActionResult GeteServicesInFunction()
        {
            StringBuilder stringBuilder = new StringBuilder();

            //sms
            ISms smsService = HttpContext.RequestServices.GetService <ISms>();

            stringBuilder.Append(smsService.SmsSend() + " \n");

            //mails
            IEnumerable <IMail> mailServices = HttpContext.RequestServices.GetServices <IMail>();

            foreach (var mail in mailServices)
            {
                stringBuilder.Append(mail.Send() + "\n");
            }

            //file Converter
            IFileConverter fileConverterService = HttpContext.RequestServices.GetService <IFileConverter>();                                    //v1
            Func <string, IFileConverter> fileConverterServiceDelg = HttpContext.RequestServices.GetService <Func <string, IFileConverter> >(); //v2

            stringBuilder.Append(fileConverterService.Convert());                                                                               //v1
            ///stringBuilder.Append(fileConverterServiceDelg("XmlConverter").Convert());//v2

            return(Content(stringBuilder.ToString()));
        }
Пример #2
0
 public override void Enqueue(ISms sms)
 {
     using (var db = new SmsLogDataContext())
     {
         db.SmsQueue_Enqueue(sms);
     }
 }
Пример #3
0
        protected override ISmsStatusCollection OnSend(ISms sms)
        {
            ASPSMSNET aspsms;
            SmsStatusCollection status;
            SmsStatus smsStatus;

            aspsms = new ASPSMSNET
            {
                UserKey = Provider.Configuration.Settings["userKey"],
                Password = Provider.Configuration.Settings["password"],
                Originator = sms.Sender,
                MessageData = sms.Message,
            };

            foreach (string recipient in sms.Recipients)
                aspsms.Recipients.Add(recipient, ToInt(sms.ReferenceId));

            if (Provider.TestMode == false)
                aspsms.SendTextSMS();

            status = new SmsStatusCollection(sms);
            if ((aspsms.ErrorCode != 1) && (Provider.TestMode == false))
                status.SetError(aspsms.ErrorCode, aspsms.ErrorDescription);

            foreach (string recipient in sms.Recipients)
            {
                smsStatus = new SmsStatus(recipient) {TestMode = Provider.TestMode};
                if (status.Successful == false)
                    smsStatus.SetError(EnMtStatus.Failure, status.ErrorCode, status.ErrorMessage);
                status.Add(smsStatus);
            }

            return status;
        }
Пример #4
0
        protected override ISmsStatusCollection OnSend(ISms sms)
        {
            SmsStatusCollection status;
            SmsStatus smsStatus;
            int? failCode = null;

            if (sms.CustomProperties.ContainsKey("FailCode"))
                failCode = int.Parse(sms.CustomProperties["FailCode"].ToString()	);

            status = new SmsStatusCollection(sms);
            for (int count = 0; count < sms.Recipients.Count; ++count)
            {
                smsStatus = new SmsStatus(sms.Recipients[count]);
                smsStatus.ProviderReference = sms.ReferenceId.ToString();
                if (failCode != null)
                    smsStatus.SetError(EnMtStatus.Failure, (int) failCode, "Error forced for testing purposes");
                else
                {
                    if (sms.CustomProperties.ContainsKey(count.ToString()))
                        smsStatus.SetError(EnMtStatus.Failure, -1, "Error forced using sms custom properties");
                }

                status.Add(smsStatus);
            }

            return status;
        }
Пример #5
0
        /// <inheritdoc/>
        public ISmsSendResult SendSms(ISms sms)
        {
            try
            {
                if (!sms?.IsValid(_smsServiceConfig) ?? true)
                {
                    throw new Exception("Invalid SMS request.");
                }

                var paramDict = new Dictionary <string, string>();
                paramDict.Add(_smsServiceConfig.MessageMask, sms.Message);
                paramDict.Add(_smsServiceConfig.RecepientMask, sms.Recepient);
                _smsServiceConfig?.RequestParameters?.ToList()?.ForEach(x => paramDict?.Add(x.Key, x.Value));
                HttpWebRequest request   = null;
                string         postData  = null;
                byte[]         postBytes = null;

                switch (_smsServiceConfig.RequestContentType)
                {
                case RequestContentType.FormData:
                    NameValueCollection outgoingQueryString = HttpUtility.ParseQueryString(string.Empty);
                    paramDict?.ToList()?.ForEach(x => outgoingQueryString.Add(x.Key, x.Value));
                    postData            = outgoingQueryString?.ToString();
                    postBytes           = _smsServiceConfig.Encoding.GetBytes(postData);
                    request             = (HttpWebRequest)WebRequest.Create(_smsServiceConfig.BaseUrl);
                    request.ContentType = "application/form-data";
                    break;

                case RequestContentType.JSON:
                    postData            = JsonConvert.SerializeObject(paramDict);
                    postBytes           = _smsServiceConfig.Encoding.GetBytes(postData);
                    request             = (HttpWebRequest)WebRequest.Create(_smsServiceConfig.BaseUrl);
                    request.ContentType = "application/json";
                    break;

                default:    //Handles Enums.RequestContentType.URL too
                    string @params = String.Join("&&", paramDict?.Select(x => $"{x.Key}={x.Value}")?.ToArray());
                    string url     = _smsServiceConfig.BaseUrl + '?' + @params;
                    request = (HttpWebRequest)WebRequest.Create(url);
                    break;
                }

                request.Method = _smsServiceConfig.RequestMethod.Method;
                if (postBytes != null)
                {
                    using (var stream = request.GetRequestStream())
                    {
                        stream.Write(postBytes, 0, postBytes.Length);
                    }
                }

                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                return(new SmsSendResult(sms.Recepient, response.StatusCode, response.GetResponseStream()));
            }
            catch (Exception e)
            {
                return(new SmsSendResult(sms.Recepient, e.Message));
            }
        }
Пример #6
0
        public void SmsQueue_Enqueue(ISms sms)
        {
            ISingleResult<SmsQueue_EnqueueResult> ret;
            SmsQueue_EnqueueResult res;
            ret = SmsQueue_Enqueue(sms.ReferenceId, sms.ApplicationId, sms.Sender, sms.Recipients.Count, sms.Message, DateTime.Now, ConvertRecipients(sms.Recipients));

            res = ret.ReturnValue as SmsQueue_EnqueueResult;
        }
Пример #7
0
 public override void OnAcceptance(ISms sms, DateTime timeStamp)
 {
     using (var db = new SmsLogDataContext())
     {
         db.SmsLog_Insert(sms, timeStamp);
         db.SubmitChanges();
     }
 }
Пример #8
0
 public SmsBase(string apiId, bool isTest)
 {
     m_apiId = apiId;
     SmsError = new SmsError();
     Sms = new Sms(this);
     SmsAccount = new SmsAccount(this);
     m_isTest = isTest;
 }
Пример #9
0
        public SmsRecipientFormatException(ISms sms, RecipientFormatError[] recipientFormatErrors)
            : base(sms, EnSmsFormat.InvalidRecipient, 
				recipientFormatErrors.Length == 1 ? 
					string.Format("Invalid SMS: 1 empty or invalid recipient") :
					string.Format("Invalid SMS: {0} empty or invalid recipients", recipientFormatErrors.Length))
        {
            _recipientFormatErrors = recipientFormatErrors;
        }
 public PedidoService(ICarrinho carrinho, IPagamento pagamento, IEstoque estoqueService, IMail mailService,
                      ISms smsService)
 {
     _carrinhoService  = carrinho;
     _pagamentoService = pagamento;
     _estoqueService   = estoqueService;
     _mailService      = mailService;
     _smsService       = smsService;
 }
Пример #11
0
        public static void SmsLog_Submitted(ISms sms, ISmsStatusCollection status, DateTime timeStamp)
        {
            using (var db = new SmsLogDataContext())
            {
                for (int count = 0; count < status.Count; ++count)
                    db.SmsLog_Forwarded(sms.ReferenceId, status[count].ProviderReference, timeStamp, sms.Recipients[count], status[count].Status < 0, status[count].ErrorCode, status[count].ErrorMessage);

                db.SubmitChanges();
            }
        }
 private readonly Func <string, IFileConverter> _fileConverterDelg; //v2
 public HomeController(ISms sms,
                       IEnumerable <IMail> mails,
                       IFileConverter fileConverter,                   //v1
                       Func <string, IFileConverter> fileConverterDelg //v2
                       )
 {
     _sms               = sms;
     _mails             = mails;
     _fileConverter     = fileConverter;     //v1
     _fileConverterDelg = fileConverterDelg; //v2
 }
Пример #13
0
 public bool Enviar(Cliente cliente, ISms iSms)
 {
     //using (var sms = new SMSConnection())
     //{
     //    sms.to = "193232339223";
     //    sms.sender;
     //}
     iSms.Enviar();
     Console.WriteLine("Salvando o objeto no banco de dados");
     return(true);
 }
Пример #14
0
        public override void OnSubmissionFailure(ISms sms, ISmsStatusCollection status, DateTime timeStamp)
        {
            int failures = 0;

            WriteLine(string.Format("**Failure: {0}", sms));
            foreach (ISmsStatus st in status)
            {
                WriteIndented(st.ToString());
                if (st.Status < 0)
                    failures++;
            }

            WriteIndented(string.Format("Number of failures: {0}", failures));
        }
Пример #15
0
 public static void SetSmsInterface(SmsInterfaceType interfaceType, string account, string password)
 {
     switch (interfaceType)
     {
         case SmsInterfaceType.IHUYI:
             sms = IHUYISms.Initialize(account, password);
             break;
         case SmsInterfaceType.C123:
             sms = C123Sms.Initialize(account, password);
             break;
         default:
             throw new NotImplementedException();
     }
 }
Пример #16
0
        /// <summary>
        /// Send an immediate sms message to multiple recipients
        /// </summary>
        /// <remarks>
        /// To be used when the number of recipients is greater than 1
        /// </remarks>
        /// <exception cref="InvalidSmsOperationException">
        ///		<see cref="EnSmsOperation.AlreadyProcessed"/>:
        ///   If the SMS has been already processed
        /// </exception>
        /// <param name="message">The message to be sent</param>
        /// <returns>
        /// A collection of <see cref="ISmsStatus" /> containing
        /// the status for each recipient
        /// </returns>
        public ISmsStatusCollection SendMultipleImmediate(ISms message)
        {
            ISmsStatusCollection status;
            ISmsProvider smsProvider;
            ISmsGateway smsGateway;
            Sms sms;

            sms = (Sms) message;

            PreProcessSms(sms);

            smsProvider = sms.Provider ?? _defaultSmsProvider;

            if (smsProvider == null)
                throw new ProviderNotFoundException();

            sms.Provider = smsProvider;

            NotifyAcceptance(sms);

            smsGateway = _smsGateways[smsProvider.Name];
            status = smsGateway.Send(sms);

            if (status.Successful)
                NotifySubmission(sms, status);
            else
                NotifySubmissionFailure(sms, status);

            sms.SetProcessed();

            return status;
        }
Пример #17
0
 protected SmsFormatException(ISms sms, EnSmsFormat enSmsFormat, string message)
     : base(message)
 {
     _enSmsFormat = enSmsFormat;
     _sms = sms;
 }
Пример #18
0
 public ProfileController(ISms sms)
 {
     _sms         = sms;
     _repoProfile = new RepoProfile();
     db           = new ApplicationDbContext();
 }
Пример #19
0
 public override void OnSubmissionFailure(ISms sms, ISmsStatusCollection status, DateTime timeStamp)
 {
     SmsLogDataContext.SmsLog_Submitted(sms, status, timeStamp);
 }
Пример #20
0
 public override void OnEnqueuement(ISms sms, DateTime timeStamp)
 {
 }
Пример #21
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LawsController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public LawsController(IServiceFactory _serviceFactory, ISms _sms) :
     base(_serviceFactory, _sms)
 {
 }
Пример #22
0
        /// <summary>
        /// Forward a SMS Send request to the gateway
        /// Made a private method to allow refreshing of the 
        /// session id - if session is expired, it attempts
        /// 1 time only, then if the error persists 
        /// does not retry anymore
        /// </summary>
        /// <param name="sms">The sms to be sent</param>
        /// <param name="refresingSession">
        /// true if the session id is expired and a new send attempt is
        /// being done after reconnecting with a new session id
        /// </param>
        /// <returns></returns>
        private ISmsStatusCollection Send(ISms sms, bool refresingSession)
        {
            ISmsStatusCollection status;
            SmsStatus smsStatus;
            string[] errorMessages;
            bool retry = false;

            if (Provider.TestMode == false)
            {
                string[] recipients;

                recipients = new string[sms.Recipients.Count];
                for (int count = 0; count < sms.Recipients.Count; ++count)
                    recipients[count] = sms.Recipients[count];

                lock (_server)
                {
                    errorMessages = _server.sendmsg(_sessionId, _apiId, null, null, recipients, sms.Sender, sms.Message, 0, 1, 0, 0, 3, 0, 3, 1, 0, sms.ReferenceId.ToString(), 0, "SMS_TEXT", string.Empty, string.Empty, 1440);
                    if ((errorMessages.Length == 1) && (IsSessionError(errorMessages[0]) && (refresingSession == false)))
                    {
                        Connect();
                        retry = true;
                    }
                }
            }
            else
                errorMessages = new string[sms.Recipients.Count];

            if (retry)
                status = Send(sms, true);
            else
            {
                status = new SmsStatusCollection(sms);
                for (int count = 0; count < sms.Recipients.Count; ++count)
                {
                    smsStatus = new SmsStatus(sms.Recipients[count]);
                    smsStatus.TestMode = Provider.TestMode;

                    CheckResponse(smsStatus, errorMessages[count]);

                    status.Add(smsStatus);
                }
            }

            return status;
        }
Пример #23
0
 /// <summary>
 /// Privat24 SMS API
 /// </summary>
 /// <param name="login"></param>
 /// <param name="password"></param>
 /// <param name="apikey"></param>
 public SmsSender(string login, string password, string apikey)
 {
     Sender = new AlphaSmsManager(login, password, apikey);
 }
Пример #24
0
 public SmsSenderFormatException(ISms sms, EnSmsSenderFormat senderFormatError)
     : base(sms, EnSmsFormat.InvalidSender, string.Format("Invalid sender"))
 {
     _smsSenderFormat = senderFormatError;
 }
Пример #25
0
 public SmsBodyFormatException(ISms sms, EnSmsBodyFormat bodyFormatError)
     : base(sms, EnSmsFormat.InvalidBody, string.Format("Invalid body"))
 {
     _smsBodyFormat = bodyFormatError;
 }
Пример #26
0
        /// <summary>
        /// Send an immediate sms message to a single recipient
        /// </summary>
        /// <remarks>
        /// This method must be used for a single recipient only.<br/>
        /// For multiple recipients use <see cref="SendMultipleImmediate"/>
        /// </remarks>
        /// <exception cref="InvalidSmsOperationException">
        ///		<see cref="EnSmsOperation.AlreadyProcessed" />: 
        ///   If the SMS has already been processed
        /// </exception>
        /// <exception cref="InvalidSmsOperationException">
        ///   <see cref="EnSmsOperation.MultipleRecipients" />:
        ///   If more than 1 recipient has been added
        /// </exception>
        /// <param name="message">The message to be sent</param>
        /// <returns>
        /// <see cref="ISmsStatus"/> instance containing status information
        /// </returns>
        public ISmsStatus SendImmediate(ISms message)
        {
            if (message.Recipients.Count > 1)
                throw new InvalidSmsOperationException(EnSmsOperation.MultipleRecipients, message);

            return SendMultipleImmediate(message)[0];
        }
Пример #27
0
        public void Enqueue(ISms message)
        {
            Sms sms;

            sms = (Sms) message;

            PreProcessSms(sms);

            //NotifyAcceptance(sms);

            _defaultQueueHandler.Enqueue(sms);

            NotifyEnqueuement(sms);
        }
Пример #28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ArticlesController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public ArticlesController(IServiceFactory _serviceFactory, ISms _sms)
     : base(_serviceFactory, _sms)
 {
 }
Пример #29
0
 public override void OnAcceptance(ISms sms, DateTime timeStamp)
 {
     WriteLine(string.Format("Accepted:  {0}", sms));
 }
Пример #30
0
 /// <summary>
 /// Privat24 SMS API
 /// </summary>
 /// <param name="merchantId"></param>
 /// <param name="merchantPassword"></param>
 public SmsSender(int merchantId, string merchantPassword)
 {
     Sender = new Privat24Manager(merchantId, merchantPassword);
 }
Пример #31
0
 public override void OnEnqueuement(ISms sms, DateTime timeStamp)
 {
     WriteLine(string.Format("Enqueued:  {0}", sms));
 }
Пример #32
0
 /// <summary>
 /// Initializes a new instance of the <see cref="BaseController"/> class.
 /// </summary>
 /// <param name="serviceFactory">The service factory.</param>
 /// <param name="sms">The SMS.</param>
 public BaseController(IServiceFactory serviceFactory, ISms sms)
 {
     Guard.NotNull(serviceFactory, nameof(serviceFactory));
     _serviceFactory = serviceFactory;
     _sms            = sms;
 }
Пример #33
0
 public override void OnSubmission(ISms sms, ISmsStatusCollection status, DateTime timeStamp)
 {
     WriteLine(string.Format("Submitted: {0}", sms));
     foreach (ISmsStatus st in status)
         WriteIndented(st.ToString());
 }
Пример #34
0
 protected override ISmsStatusCollection OnSend(ISms sms)
 {
     return Send(sms, false);
 }
Пример #35
0
 #pragma warning disable CS3001 // Argument type is not CLS-compliant
 /// <summary>
 /// Constructor which accepts the sms as a parameter which is a dependency.
 /// This dependency is configured in the UnityConfig file inside RegisterTypes function
 /// This is inside ServiceLocation folder
 /// </summary>
 /// <param name="sms"></param>
 public SmsBL(Sms sms)
 {
     _sms = sms;
 }
Пример #36
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UtilityController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public UtilityController(IServiceFactory _serviceFactory, ISms _sms) :
     base(_serviceFactory, _sms)
 {
 }
 public Notification(IMail mail, ISms sms)
 {
     _mail = mail;
     _sms  = sms;
 }
Пример #38
0
 public void SmsLog_Insert(ISms sms, DateTime timeStamp)
 {
     SmsLog_Insert(sms.ReferenceId, sms.ApplicationId, sms.Sender, sms.Recipients.Count, sms.Message, timeStamp, ConvertRecipients(sms.Recipients), false);
 }
Пример #39
0
 public AlertController(ISms sms, IOptions <SmsAlertConfig> config)
 {
     _sms    = sms;
     _config = config;
 }
Пример #40
0
 public SmsFormatException(ISms sms, EnSmsFormat enSmsFormat)
     : base(string.Format("Invalid SMS format - Reason: {0}", enSmsFormat))
 {
     _enSmsFormat = enSmsFormat;
     _sms = sms;
 }
Пример #41
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EmiratesController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public EmiratesController(IServiceFactory _serviceFactory, ISms _sms)
     : base(_serviceFactory, _sms)
 {
 }
Пример #42
0
 public Teacher2Controller( )
 {
     ob = new Sms();
     //   dbContext = new AppDbContext();
     DbService = new TeacherDbService();
 }
Пример #43
0
        public void RunDequeuingThreads()
        {
            IDequeueService dequeuers;
            Mock<SqlServerLogProvider> mockLogProvider;
            ISmsc smsc;
            ISms[] messages;

            mockLogProvider = MockManager.Mock<SqlServerLogProvider>(Constructor.NotMocked);
            mockLogProvider.ExpectCall("OnEnqueuement", 20);

            smsc = SmsFactory.GetSmsc();

            // Create and enqueue 20 messages
            messages = new ISms[20];
            for (int count = 0; count < 20; ++count)
            {
                messages[count] = SmsFactory.NewSms(TestConstants.Default_ApplicationId);
                messages[count].Sender = TestConstants.Default_Sender;
                messages[count].AddRecipient(TestConstants.Default_Recipient);
                messages[count].Message = string.Format("Message {0}", count + 1);
                smsc.Enqueue(messages[count]);
            }

            mockLogProvider = MockManager.Mock<SqlServerLogProvider>(Constructor.NotMocked);
            mockLogProvider.ExpectCall("OnSubmission", 20);

            // Instantiate a dequeuer with 5 instances
            dequeuers = SmsFactory.CreateDequeueService(5);

            Assert.IsFalse(dequeuers.IsQueueEmpty());

            // Run the 5 dequeuer threads
            dequeuers.Start();

            Thread.Sleep(2000);

            // Wait until all dequeuer threads are idle
            dequeuers.Suspend();

            Assert.IsTrue(dequeuers.IsQueueEmpty());

            dequeuers.Terminate();
        }
Пример #44
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CampaignController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public CampaignController(IServiceFactory _serviceFactory, ISms _sms)
     : base(_serviceFactory, _sms)
 {
 }
Пример #45
0
 protected void NotifySubmission(ISms sms, ISmsStatusCollection status)
 {
     if (OnSubmission != null) OnSubmission(sms, status, DateTime.Now);
 }
Пример #46
0
 public SmsRecipientFormatException(ISms sms)
     : base(sms, EnSmsFormat.InvalidRecipient, "Invalid SMS: no recipient")
 {
     _recipientFormatErrors = new RecipientFormatError[0];
 }
Пример #47
0
 /// <summary>
 /// 通过短信发送验证码
 /// </summary>
 /// <param name="formatter">验证码内容模板</param>
 /// <param name="sms">短信发送接口</param>
 public SmsSender(IContentFormatter formatter, ISms sms)
 {
     this.Formatter = formatter ?? throw new ArgumentNullException(nameof(formatter));
     this.Sms       = sms ?? throw new ArgumentNullException(nameof(sms));
 }
Пример #48
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ContactTypeController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public ContactTypeController(IServiceFactory _serviceFactory, ISms _sms) : base(_serviceFactory, _sms)
 {
 }
Пример #49
0
 public SmsNotificationArgs(ISms sms, ISmsStatus smsStatus)
 {
     _sms = sms;
     _smsStatus = smsStatus;
 }
Пример #50
0
        public void EnqueueAndDequeueMultipleMessages()
        {
            ISmsc smsc;
            ISms[] messages;

            messages = new ISms[5];

            smsc = SmsFactory.GetSmsc();

            // Verify the queue is empty
            Assert.IsTrue(smsc.IsQueueEmpty());

            for (int count = 0; count < 5; ++count)
            {
                messages[count] = SmsFactory.NewSms(TestConstants.Default_ApplicationId);
                messages[count].Sender = TestConstants.Default_Sender;
                messages[count].AddRecipient(TestConstants.Default_Recipient);
                messages[count].Message = string.Format("Message {0}", count + 1);
                smsc.Enqueue(messages[count]);
            }

            // Verify the queue is not empty
            Assert.IsFalse(smsc.IsQueueEmpty());

            for (int count = 0; count < 5; ++count)
            {
                using (var dequeuer = smsc.GetDequeuer())
                {
                    var enqueuedSms = dequeuer.Dequeue();
                    dequeuer.DequeueCommit(true);
                    Helpers.CompareSms(messages[count], enqueuedSms);
                }
            }

            // Verify the queue is empty
            Assert.IsTrue(smsc.IsQueueEmpty());
        }
Пример #51
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DecisionController"/> class.
 /// </summary>
 /// <param name="_serviceFactory">The service factory.</param>
 /// <param name="_sms">The SMS.</param>
 public DecisionController(IServiceFactory _serviceFactory, ISms _sms)
     : base(_serviceFactory, _sms)
 {
 }
Пример #52
0
 public Helper(ISms sms)
 {
     _sms = sms;
 }
Пример #53
0
 public CommonController(ISms smsRepository)
 {
     _smsRepository = smsRepository;
 }