using StecPoint.ES.Infrastructure.Integration.Interfaces.Abstract;
using StecPoint.ES.SendSay.Sdk.Model.Response;

namespace StecPoint.ES.Infrastructure.Integration.SendSay
{
    class SendSayList : ServiceListAbstract
    {
        public SendSayList()
        {

        }

        public SendSayList(List x)
        {
            Id = x.Id;
            Name = x.Name;
        }
    }
}

using StecPoint.ES.Infrastructure.Integration.Interfaces.Abstract;
using StecPoint.ES.Infrastructure.Integration.Interfaces.Dto;
using StecPoint.ES.SendSay.Sdk.Model.Request;

namespace StecPoint.ES.Infrastructure.Integration.SendSay
{
    public class SendSayMember : ServiceListMemberAbstract
    {
        public SendSayMember()
        {

        }

        public SendSayMember(MemberDto x)
        {
            ListId = x.ListId;
            Email = x.Email;
            PhoneNumber = x.PhoneNumber;
            Params = x.Params;
            FirstName = x.FirstName;
            LastName = x.LastName;
        }
    public Subscriber GetSubscriber()
    {
        var subs = new Subscriber
        {
            Email = Email,
            GroupId = "" // !
        };
        return subs;
    }
}

using StecPoint.ES.Infrastructure.Integration.Interfaces.Abstract;
using StecPoint.ES.SendSay.Sdk.Model.Response;

namespace StecPoint.ES.Infrastructure.Integration.SendSay
{
    public class SendSayProperty : ServiceParamAbstract
    {
        public SendSayProperty()
        {

        }

        public SendSayProperty(Quest x)
        {
            Id = x.Id;
            Name = x.Name;
        }
    }
}






using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using StecPoint.ES.Infrastructure.Integration.Interfaces;
using StecPoint.ES.Infrastructure.Integration.Interfaces.Abstract;
using StecPoint.ES.Infrastructure.Integration.Interfaces.Dto;
using StecPoint.ES.SendSay.Sdk.Manager;
using StecPoint.ES.SendSay.Sdk.Model;
using StecPoint.ES.SendSay.Sdk.Model.Response;

namespace StecPoint.ES.Infrastructure.Integration.SendSay
{
    public class SendSayServiceProvider : IPartnerServiceProvider
    {
        private readonly SendSayManager _manager;

        public SendSayServiceProvider(AuthConfigAbstract config)
        {
            var apiConfig = new ApiConfig { UserName = config.UserName,
                                            Password = config.Password};
            _manager = new SendSayManager(apiConfig);
        }

        public async Task<ServerResponseDto> ValidateApiKeyAsync()
        {
            var status = await _manager.Subscribers.ValidateRequestAsync();
            return new ServerResponseDto() { Status = status };
        }

        public async Task<IEnumerable<ServiceListAbstract>> GetListsAsync()
        {
            var res = new List<SendSayList>();
            try
            {
                var lists = await _manager.Lists.GetAllAsync();
                res = lists
                    .Select(x => new SendSayList(x))
                    .ToList();

                var listParams = (await GetListParamsAsync(string.Empty, null)).ToList();

                foreach (var item in res)
                {
                    item.ServiceListParams = listParams;
                }
            }
            catch
            {
                // ignore
            }
            return res;
        }



        public async Task<ServiceListAbstract> GetListByIdAsync(string id)
        {
            //return await Task.Run(() => new WebHookList());
            return null; // !
        }

        public async Task<IEnumerable<ServiceParamAbstract>> GetListParamsAsync(string listId, string[] standartParams)
        {
            var res = new List<SendSayProperty>();
            var lists = await _manager.Fields.GetAllAsync();
            res = lists
                  .Select(x => new SendSayProperty(x))
                  .ToList();
            return res;
        }

        public async Task<IEnumerable<ServiceParamAbstract>> GetListParamsAsync(string listId, bool addEmailParam)
        {
            //return await GetListParamsAsync(listId, null);
            return null; // !
        }

        public async Task<ServiceListMemberAbstract> AddListMember(MemberDto member)
        {
            SendSayMember res = null;
            try
            {
                var sendSayMember = new SendSayMember(member);
                var subs = sendSayMember.GetSubscriber();

                var newMembers = await _manager.Subscribers.AddAsync(subs);

                return new SendSayMember
                {
                    Id = newMembers.Id
                };
            }
            catch
            {
                // ignore
            }
            return res;
        }

        public async Task<IEnumerable<int>> GetEmailTemplatesAsync()
        {
            IEnumerable<int> emailTemplates = await _manager.EmailTemplates.GetAllAsync();
            return emailTemplates;
        }
    }
}




using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using StecPoint.ES.SendSay.Sdk.Interface;
using StecPoint.ES.SendSay.Sdk.Model.Response;
using Newtonsoft.Json;
using System.Linq;
using RestSharp;
using Newtonsoft.Json.Linq;
using System.Collections;

namespace StecPoint.ES.SendSay.Sdk.Manager
{
    public class EmailTemplateManager : ManagerBase, IEmailTemplateManager
    {
        public EmailTemplateManager(IApiConfig config) : base(config)
        {
        }

        public async Task<IEnumerable<int>> GetAllAsync()
        {
            try
            {
                RestClient client = GetApiClient();
                RestRequest formsRequest = GetBaseRequest("infolett.list");
                CancellationTokenSource cancelTokenSrc = new CancellationTokenSource();
                IRestResponse formsResp = null;
                try
                {
                    formsResp = await client.ExecuteTaskAsync(formsRequest, cancelTokenSrc.Token);
                }
                catch (Exception e)
                {
                }
                if (formsResp.StatusCode != HttpStatusCode.Created && formsResp.StatusCode != HttpStatusCode.OK)
                {
                    Logger?.Error($"Server return error: {formsResp.StatusCode}");
                }
                IEnumerable<int> templates = JsonConvert.DeserializeObject<EmailTemplateList>(formsResp.Content).List.Select(x => x.Id).ToArray();
                return templates;
            }
            catch (Exception e)
            {
                Logger?.Error(e);
                return null;
            }
        }
    }
}





using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using StecPoint.ES.SendSay.Sdk.Interface;
using StecPoint.ES.SendSay.Sdk.Model.Response;
using Newtonsoft.Json;
using System.Linq;
using RestSharp;
using Newtonsoft.Json.Linq;
using System.Collections;

namespace StecPoint.ES.SendSay.Sdk.Manager
{
    public class FieldManager : ManagerBase, IFieldManager
    {
        public FieldManager(IApiConfig config) : base(config)
        {
        }

        public async Task<IList<Quest>> GetAllAsync()
        {
            try
            {
                RestClient client = GetApiClient();
                RestRequest formsRequest = GetBaseRequest("anketa.list");
                CancellationTokenSource cancelTokenSrc = new CancellationTokenSource();
                IRestResponse formsResp = await client.ExecuteTaskAsync(formsRequest, cancelTokenSrc.Token);
                if (formsResp.StatusCode != HttpStatusCode.Created && formsResp.StatusCode != HttpStatusCode.OK)
                {
                    Logger?.Error($"Server return error: {formsResp.StatusCode}");
                }
                List<Quest> quests = new List<Quest>();
                string[] formIds = JsonConvert.DeserializeObject<FormList>(formsResp.Content).List.Select(x => x.Id).ToArray();
                foreach (string formId in formIds)
                {
                    RestRequest readFormRequest = GetBaseRequest("anketa.get");
                    Parameter requestParam = readFormRequest.Parameters.FirstOrDefault(x => x.Name == "request");
                    requestParam.Value = AddObject(requestParam, "id", formId);

                    IRestResponse readFormResp = await client.ExecuteTaskAsync(readFormRequest, cancelTokenSrc.Token);
                    dynamic json = JArray.Parse('[' + readFormResp.Content + ']');
                    IEnumerable<Quest> questsFromJSON = ((IEnumerable)json[0].obj.quests)
                                                        .Cast<dynamic>()
                                                        .Select(x => Deserialize(x))
                                                        .Cast<Quest>()
                                                        .Select(x => new Quest(x.Id, x.Name));
                    quests.AddRange(questsFromJSON);
                }
                return quests;
            }
            catch (Exception e)
            {
                Logger?.Error(e);
                return null;
            }
        }

        public async Task<IEnumerable<FormWithQuests>> GetFormsWithQuestsAsync()
        {
            try
            {
                RestClient client = GetApiClient();
                RestRequest formsRequest = GetBaseRequest("anketa.list");
                CancellationTokenSource cancelTokenSrc = new CancellationTokenSource();
                IRestResponse formsResp = await client.ExecuteTaskAsync(formsRequest, cancelTokenSrc.Token);
                if (formsResp.StatusCode != HttpStatusCode.Created && formsResp.StatusCode != HttpStatusCode.OK)
                {
                    Logger?.Error($"Server return error: {formsResp.StatusCode}");
                }
                List<FormWithQuests> formsWithQuests = new List<FormWithQuests>();
                string[] formIds = JsonConvert.DeserializeObject<FormList>(formsResp.Content).List.Select(x => x.Id).ToArray();
                foreach (string formId in formIds)
                {
                    RestRequest readFormRequest = GetBaseRequest("anketa.get");
                    Parameter requestParam = readFormRequest.Parameters.FirstOrDefault(x => x.Name == "request");
                    requestParam.Value = AddObject(requestParam, "id", formId);

                    IRestResponse readFormResp = await client.ExecuteTaskAsync(readFormRequest, cancelTokenSrc.Token);
                    dynamic json = JArray.Parse('[' + readFormResp.Content + ']');
                    IEnumerable<Quest> questsFromJSON = ((IEnumerable)json[0].obj.quests)
                                                        .Cast<dynamic>()
                                                        .Select(x => Deserialize(x))
                                                        .Cast<Quest>()
                                                        .Select(x => new Quest(x.Id, x.Name));
                    formsWithQuests.Add(new FormWithQuests(formId, questsFromJSON));

                }
                return formsWithQuests;
            }
            catch (Exception e)
            {
                Logger?.Error(e);
                return null;
            }
        }

        Func<dynamic, dynamic> Deserialize = delegate (dynamic q)
        {
            return (dynamic)JsonConvert.DeserializeObject<Quest>(q.Value.ToString()
                                                                  .Replace("rn", string.Empty));
        };
    }
}



using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using StecPoint.ES.SendSay.Sdk.Interface;
using StecPoint.ES.SendSay.Sdk.Model.Response;
using Newtonsoft.Json;

namespace StecPoint.ES.SendSay.Sdk.Manager
{
    public class ListManager : ManagerBase, IListManager
    {
        public ListManager(IApiConfig config) : base(config)
        {
        }

        public async Task<IList<List>> GetAllAsync()
        {
            try
            {
                var client = GetApiClient();
                var request = GetBaseRequest("group.list");
                var cancelTokenSrc = new CancellationTokenSource();
                var resp = await client.ExecuteTaskAsync<ListResult>(request, cancelTokenSrc.Token);
                if (resp.StatusCode != HttpStatusCode.Created && resp.StatusCode != HttpStatusCode.OK)
                {
                    Logger?.Error($"Server return error: {resp.StatusCode}");
                }
                try
                {
                    ListResult lists = JsonConvert.DeserializeObject<ListResult>(resp.Content);
                    return lists.List;
                }
                catch (Exception e)
                {
                    Logger?.Error(e);
                    return null;
                }
            }
            catch (Exception e)
            {
                Logger?.Error(e);
                return null;
            }
        }
    }
}



using System;
using NLog;
using RestSharp;
using StecPoint.ES.SendSay.Sdk.Interface;
using Newtonsoft.Json;

namespace StecPoint.ES.SendSay.Sdk.Manager
{
    public class ManagerBase
    {
        protected readonly IApiConfig ApiConfig;
        protected readonly ILogger Logger;
        private static readonly string _baseApiServer = "https://api.sendsay.ru/clu206";

        public ManagerBase(IApiConfig config)
        {
            ApiConfig = config;
            Logger = config.Logger;
        }

        protected RestClient GetApiClient()
        {
            var client = new RestClient
            {
                BaseUrl = new Uri(_baseApiServer)
            };
            return client;
        }

        public RestRequest GetBaseRequest(string action)
        {
            RestRequest request = new RestRequest(_baseApiServer, Method.POST);
            request.AddParameter("apiversion", "100");
            request.AddParameter("json", "1");
            UserName username = new UserName(ApiConfig.UserName);
            string json = JsonConvert.SerializeObject(
                          new
                          {
                              one_time_auth = new
                              {
                                  login = username.Login,
                                  sublogin = username.Sublogin,
                                  passwd = ApiConfig.Password
                              },
                              action = action
                          });
            request.AddParameter("request", json);
            return request;
        }

        protected string AddObject(Parameter param, string key, string value)
        {
            value = key == "obj" ? value : '"'+value+'"';
            string paramVal = param.Value.ToString();
            return paramVal.Insert(paramVal.Length - 1, ","" + key + "":" + value + "");
        }
    }
}



using StecPoint.ES.SendSay.Sdk.Interface;

namespace StecPoint.ES.SendSay.Sdk.Manager
{
    public class SendSayManager : ISendSayManager
    {
        public IApiConfig ApiConfig { get; set; }

        public IListManager Lists { get; set; }

        public ISubscriberManager Subscribers { get; set; }

        public IFieldManager Fields { get; set; }

        public IEmailTemplateManager EmailTemplates { get; set; }

        public SendSayManager(IApiConfig apiConfig)
        {
            ApiConfig = apiConfig;
            Lists = new ListManager(ApiConfig);
            Subscribers = new SubscriberManager(ApiConfig);
            Fields = new FieldManager(apiConfig);
            EmailTemplates = new EmailTemplateManager(apiConfig);
        }
    }
}




using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using StecPoint.ES.SendSay.Sdk.Interface;
using StecPoint.ES.SendSay.Sdk.Model.Request;
using StecPoint.ES.SendSay.Sdk.Model.Response;
using System.Linq;
using RestSharp;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json;

namespace StecPoint.ES.SendSay.Sdk.Manager
{
    public class SubscriberManager : ManagerBase, ISubscriberManager
    {
        public SubscriberManager(IApiConfig config) : base(config)
        {

        }
        public async Task<int> ValidateRequestAsync()
        {
            try
            {
                var client = GetApiClient();
                var request = GetBaseRequest("group.list");
                var cancelTokenSrc = new CancellationTokenSource();
                var resp = await client.ExecuteTaskAsync<ListResult>(request, cancelTokenSrc.Token);
                if (resp.StatusCode != HttpStatusCode.Created && resp.StatusCode != HttpStatusCode.OK)
                {
                    Logger?.Error($"Server return error: {resp.StatusCode}");
                    return (int)resp.StatusCode;
                }
                return 200;
            }
            catch (Exception e)
            {
                Logger?.Error(e);
                return (int)HttpStatusCode.ServiceUnavailable;
            }
        }

        public async Task<Person> AddAsync(Subscriber subscriber)
        {
            try
            {
                RestClient client = GetApiClient();
                RestRequest request = GetBaseRequest("member.set");

                Parameter requestParam = request.Parameters.FirstOrDefault(x => x.Name == "request");
                requestParam.Value = AddObject(requestParam, "email", subscriber.Email);
                requestParam.Value = AddObject(requestParam, "newbie.confirm", subscriber.OptIn ? "1" : "0");
                if (subscriber.OptIn)
                    requestParam.Value = AddObject(requestParam, "newbie.letter.confirm", subscriber.TemplateId.ToString());

                requestParam.Value = AddObject(requestParam, "obj", await GetObjVal(subscriber.GroupId));

                CancellationTokenSource cancelTokenSrc = new CancellationTokenSource();
                IRestResponse resp = await client.ExecuteTaskAsync(request, cancelTokenSrc.Token);
                if (resp.StatusCode != HttpStatusCode.Created && resp.StatusCode != HttpStatusCode.OK)
                {
                    Logger?.Error($"Server return error: {resp.StatusCode}");
                }
                SubscriberResponse data = JsonConvert.DeserializeObject<SubscriberResponse>(resp.Content);
                return data.Member;
            }
            catch (Exception e)
            {
                Logger?.Error(e);
                return null;
            }
        }

        private async Task<string> GetObjVal(string groupId)
        {
            FieldManager fieldMng = new FieldManager(ApiConfig);
            StringBuilder objVal = new StringBuilder("{");
            IEnumerable<FormWithQuests> formsWithQuests = await fieldMng.GetFormsWithQuestsAsync();
            foreach (FormWithQuests formWithQuests in formsWithQuests)
            {
                IEnumerable<Quest> quests = formWithQuests.Quests;
                if (!quests.Any()) continue;
                objVal.Append('"').Append(formWithQuests.Id).Append('"').Append(":{");
                for (int i = 0; i < quests.Count(); i++)
                {
                    Quest quest = quests.ElementAt(i);
                    objVal.Append('"').Append(quest.Id).Append('"')
                          .Append(':')
                          .Append('"').Append(quest.Name).Append('"');
                    if (i < quests.Count() - 1)
                    {
                        objVal.Append(',');
                    }
                }
                objVal.Append("},");
            }
            objVal.Append(""-group": {"" + groupId + "":"1"}}");
            return objVal.ToString();
        }
    }
}


namespace StecPoint.ES.SendSay.Sdk.Manager
{
    class UserName
    {
        private const char delimeter = '|';
        public string Login { get; set; }
        public string Sublogin { get; set; }
        public UserName(string username)
        {
            Login = username.Split(delimeter)[0];
            Sublogin = username.Split(delimeter)[1];
        }
    }
}