files tree made better.

src/Yavsc/Services/BillingService.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Yavsc.Abstract.Workflow;
+using Yavsc.Models;
+using Microsoft.Data.Entity;
+
+namespace Yavsc.Services
+{
+    public class BillingService : IBillingService
+    {
+        public ApplicationDbContext DbContext { get; private set; }
+        private ILogger logger;
+        public static Dictionary<string,Func<ApplicationDbContext,long,IDecidableQuery>> Billing =
+        new Dictionary<string,Func<ApplicationDbContext,long,IDecidableQuery>> ();
+        public static List<PropertyInfo> UserSettings = new List<PropertyInfo>();
+        
+        public static Dictionary<string,string> GlobalBillingMap =
+          new Dictionary<string,string>();
+
+        public Dictionary<string,string> BillingMap {
+          get { return GlobalBillingMap; }
+        }
+
+        public BillingService(ILoggerFactory loggerFactory, ApplicationDbContext dbContext)
+        {
+            logger = loggerFactory.CreateLogger<BillingService>();
+            DbContext = dbContext;
+        }
+
+        public Task<IDecidableQuery> GetBillAsync(string billingCode, long queryId)
+        {
+            return Task.FromResult(GetBillable(DbContext,billingCode,queryId));
+        }
+
+        public static IDecidableQuery GetBillable(ApplicationDbContext context, string billingCode, long queryId ) =>  Billing[billingCode](context, queryId);
+        public async Task<ISpecializationSettings> GetPerformerSettingsAsync(string activityCode, string userId)
+        {
+            return await (await GetPerformersSettingsAsync(activityCode)).SingleOrDefaultAsync(s=> s.UserId == userId);
+        }
+
+        public async Task<IQueryable<ISpecializationSettings>> GetPerformersSettingsAsync(string activityCode)
+        {
+            var activity = await DbContext.Activities.SingleAsync(a=>a.Code == activityCode);
+           
+            if (activity.SettingsClassName==null) return null;
+            var dbSetPropInfo = UserSettings.SingleOrDefault(s => s.PropertyType.GenericTypeArguments[0].FullName == activity.SettingsClassName);
+  
+            if (dbSetPropInfo == null) return null;
+
+            return (IQueryable<ISpecializationSettings>) dbSetPropInfo.GetValue(DbContext);
+        }
+    }
+}

src/Yavsc/Services/EMailer.cs

@@ -0,0 +1,182 @@
+// // EMailer.cs
+// /*
+// paul  26/06/2018 12:18 20182018 6 26
+// */
+using System;
+using Microsoft.AspNet.Razor;
+using Yavsc.Templates;
+using Microsoft.CodeAnalysis;
+using Microsoft.Extensions.Localization;
+using Microsoft.Extensions.Logging;
+using Microsoft.AspNet.Identity.EntityFramework;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+
+using Yavsc.Models;
+using Yavsc.Services;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using System.Reflection;
+using Yavsc.Abstract.Templates;
+
+namespace Yavsc.Lib
+{
+    public class EMailer
+    {
+        const string DefaultBaseClassName = "ATemplate";
+        const string DefaultBaseClass = nameof(UserOrientedTemplate);
+        const string DefaultNamespace = "CompiledRazorTemplates";
+
+        RazorTemplateEngine razorEngine;
+        IStringLocalizer<EMailer> stringLocalizer;
+
+        ApplicationDbContext dbContext;
+        IEmailSender mailSender;
+        RazorEngineHost host;
+        ILogger logger;
+
+        public EMailer(ApplicationDbContext context, IEmailSender sender, 
+                       IStringLocalizer<EMailer> localizer, 
+                       ILoggerFactory loggerFactory)
+        {
+            stringLocalizer = localizer;
+            mailSender = sender;
+
+            logger = loggerFactory.CreateLogger<EMailer>();
+
+            var language = new CSharpRazorCodeLanguage();
+
+            host = new RazorEngineHost(language)
+            {
+                DefaultBaseClass = DefaultBaseClass,
+                DefaultClassName = DefaultBaseClassName,
+                DefaultNamespace = DefaultNamespace
+            };
+
+            host.NamespaceImports.Add("System");
+            host.NamespaceImports.Add("Yavsc.Templates");
+            host.NamespaceImports.Add("Yavsc.Models");
+            host.NamespaceImports.Add("Yavsc.Models.Identity");
+            host.NamespaceImports.Add("Microsoft.AspNet.Identity.EntityFramework");
+            host.InstrumentedSourceFilePath = ".";
+            host.StaticHelpers = true;
+            dbContext = context;
+            razorEngine = new RazorTemplateEngine(host);
+        }
+
+        public string GenerateTemplateObject(string baseclassName = DefaultBaseClassName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SendMonthlyEmail(long templateCode, string baseclassName = DefaultBaseClassName)
+        {
+            string className = "Generated" + baseclassName;
+
+            string subtemp = stringLocalizer["MonthlySubjectTemplate"].Value;
+
+            logger.LogInformation($"Generating {subtemp}[{className}]");
+          
+          
+            var templateInfo = dbContext.MailingTemplate.FirstOrDefault(t => t.Id == templateCode);
+
+            logger.LogInformation($"Using code: {templateCode},  subject: {subtemp} ");
+            logger.LogInformation("And body:\n" + templateInfo.Body);
+            using (StringReader reader = new StringReader(templateInfo.Body))
+            {
+
+                // Generate code for the template
+                var razorResult = razorEngine.GenerateCode(reader, className, DefaultNamespace, DefaultNamespace + ".cs");
+
+                logger.LogInformation("Razor exited " + (razorResult.Success ? "Ok" : "Ko") + ".");
+
+                logger.LogInformation(razorResult.GeneratedCode);
+                SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(razorResult.GeneratedCode);
+                logger.LogInformation("CSharp parsed");
+                List<MetadataReference> references = new List<MetadataReference>();
+
+                foreach (var type in new Type[] {
+                    typeof(object),
+                    typeof(Enumerable),
+                    typeof(IdentityUser),
+                    typeof(ApplicationUser),
+                    typeof(Template),
+                    typeof(UserOrientedTemplate),
+                    typeof(System.Threading.Tasks.TaskExtensions)
+                 })
+                {
+                    var location = type.Assembly.Location;
+                    if (!string.IsNullOrWhiteSpace(location))
+                    {
+                        references.Add(
+                            MetadataReference.CreateFromFile(location)
+                        );
+                        logger.LogInformation($"Assembly for {type.Name} found at {location}");
+                    }
+                    else logger.LogWarning($"Assembly Not found for {type.Name}");
+                }
+
+                logger.LogInformation("Compilation creation ...");
+
+                var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+                    .WithAllowUnsafe(true).WithOptimizationLevel(OptimizationLevel.Debug)
+                    .WithOutputKind(OutputKind.DynamicallyLinkedLibrary).WithPlatform(Platform.AnyCpu)
+                    .WithUsings("Yavsc.Templates")
+                    ;
+                string assemblyName = DefaultNamespace;
+                CSharpCompilation compilation = CSharpCompilation.Create(
+                    assemblyName,
+                    syntaxTrees: new[] { syntaxTree },
+                    references: references,
+                    options: compilationOptions
+                    );
+
+                using (var ms = new MemoryStream())
+                {
+                    logger.LogInformation("Emitting result ...");
+                    EmitResult result = compilation.Emit(ms);
+                    foreach (Diagnostic diagnostic in result.Diagnostics.Where(diagnostic =>
+                            diagnostic.Severity < DiagnosticSeverity.Error && !diagnostic.IsWarningAsError))
+                    {
+                        logger.LogWarning("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
+                        logger.LogWarning("{0}: {1}", diagnostic.Id, diagnostic.Location.GetLineSpan());
+                    }
+                    if (!result.Success)
+                    {
+                        logger.LogInformation(razorResult.GeneratedCode);
+                        IEnumerable<Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
+                            diagnostic.IsWarningAsError ||
+                            diagnostic.Severity == DiagnosticSeverity.Error);
+                        foreach (Diagnostic diagnostic in failures)
+                        {
+                            logger.LogCritical("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
+                            logger.LogCritical("{0}: {1}", diagnostic.Id, diagnostic.Location.GetLineSpan());
+                        }
+                    }
+                    else
+                    {
+                        logger.LogInformation(razorResult.GeneratedCode);
+                        ms.Seek(0, SeekOrigin.Begin);
+                        Assembly assembly = Assembly.Load(ms.ToArray());
+
+                        Type type = assembly.GetType(DefaultNamespace + "." + className);
+                        var generatedtemplate = (UserOrientedTemplate)Activator.CreateInstance(type);
+                        foreach (var user in dbContext.ApplicationUser.Where(
+                            u => u.AllowMonthlyEmail
+                        ))
+                        {
+                            logger.LogInformation("Generation for " + user.UserName);
+                            generatedtemplate.Init();
+                            generatedtemplate.User = user;
+                            generatedtemplate.ExecuteAsync();
+                            logger.LogInformation(generatedtemplate.GeneratedText);
+                        }
+
+                    }
+                }
+            }
+
+        }
+    }
+}

src/Yavsc/Services/GCMSender.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.OptionsModel;
+using Newtonsoft.Json;
+using Yavsc.Interfaces.Workflow;
+using Yavsc.Models.Google.Messaging;
+using Yavsc.Models.Haircut;
+using Yavsc.Models.Messaging;
+using Yavsc.Server.Helpers;
+
+namespace Yavsc.Services
+{
+    public class GCMSender : IGoogleCloudMessageSender
+    {
+        private ILogger _logger;
+        SiteSettings siteSettings;
+        GoogleAuthSettings googleSettings;
+
+        public GCMSender(
+
+            ILoggerFactory loggerFactory, 
+            IOptions<SiteSettings> sitesOptions, 
+            IOptions<SmtpSettings> smtpOptions,
+            IOptions<GoogleAuthSettings> googleOptions
+        )
+        { _logger = loggerFactory.CreateLogger<MailSender>();
+            siteSettings = sitesOptions?.Value;
+            googleSettings = googleOptions?.Value;
+
+        }
+        public  async Task <MessageWithPayloadResponse> NotifyEvent<Event>
+         (  IEnumerable<string> regids, Event ev)
+           where Event : IEvent
+        {
+            if (ev == null)
+                throw new Exception("Spécifier un évènement");
+
+            if (ev.Sender == null)
+                throw new Exception("Spécifier un expéditeur");
+
+            if (regids == null )
+                throw new NotImplementedException("Notify & No GCM reg ids");
+            var raa = regids.ToArray();
+            if (raa.Length<1)
+                 throw new NotImplementedException("No GCM reg ids");
+            var msg = new MessageWithPayload<Event>()
+            {
+                data = ev,
+                registration_ids = regids.ToArray()
+            };
+            _logger.LogInformation("Sendding to Google : "+JsonConvert.SerializeObject(msg));
+            try {
+                using (var m = new SimpleJsonPostMethod("https://gcm-http.googleapis.com/gcm/send",$"key={googleSettings.ApiKey}")) {
+                    return await m.Invoke<MessageWithPayloadResponse>(msg);
+                }
+            }
+            catch (Exception ex) {
+                throw new Exception ("Quelque chose s'est mal passé à l'envoi",ex);
+            }
+        }
+        
+
+        public async Task<MessageWithPayloadResponse> NotifyBookQueryAsync( IEnumerable<string> registrationIds, RdvQueryEvent ev)
+        {
+            return await NotifyEvent<RdvQueryEvent>(registrationIds, ev);
+        }
+
+        public async Task<MessageWithPayloadResponse> NotifyEstimateAsync(IEnumerable<string> registrationIds, EstimationEvent ev)
+        {
+            return await NotifyEvent<EstimationEvent>(registrationIds, ev);
+        }
+
+        public async Task<MessageWithPayloadResponse> NotifyHairCutQueryAsync(
+         IEnumerable<string> registrationIds, HairCutQueryEvent ev)
+        {
+            return await NotifyEvent<HairCutQueryEvent>(registrationIds, ev);
+        }
+
+        public async Task<MessageWithPayloadResponse> NotifyAsync(IEnumerable<string> regids, IEvent yaev)
+        {
+            return await NotifyEvent<IEvent>(regids, yaev);
+        }
+        
+        /* SMS with Twilio:
+public Task SendSmsAsync(TwilioSettings twilioSettigns, string number, string message)
+{
+var Twilio = new TwilioRestClient(twilioSettigns.AccountSID, twilioSettigns.Token);
+var result = Twilio.SendMessage( twilioSettigns.SMSAccountFrom, number, message);
+// Status is one of Queued, Sending, Sent, Failed or null if the number is not valid
+Trace.TraceInformation(result.Status);
+// Twilio doesn't currently have an async API, so return success.
+
+return Task.FromResult(result.Status != "Failed");
+
+}  */
+    }
+}

src/Yavsc/Services/GoogleApis/CalendarManager.cs

@@ -0,0 +1,296 @@
+//
+//  CalendarApi.cs
+//
+//  Author:
+//       Paul Schneider <paulschneider@free.fr>
+//
+//  Copyright (c) 2015 - 2017 Paul Schneider
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.OptionsModel;
+using Google.Apis.Auth.OAuth2;
+using Google.Apis.Util.Store;
+using Google.Apis.Calendar.v3;
+using Google.Apis.Calendar.v3.Data;
+using System.Collections.Generic;
+using System.Linq;
+using Google.Apis.Services;
+using System.Threading;
+using Google.Apis.Auth.OAuth2.Flows;
+using Google.Apis.Auth.OAuth2.Responses;
+using Google.Apis.Util;
+
+namespace Yavsc.Services
+{
+    using Yavsc.Helpers;
+    using Yavsc.Models;
+    using Yavsc.Models.Calendar;
+    using Yavsc.Server.Helpers;
+    using Yavsc.ViewModels.Calendar;
+
+    /// <summary>
+    /// Google Calendar API client.
+    /// </summary>
+    public class CalendarManager : ICalendarManager 
+    {
+        public class ExpiredTokenException : Exception { }
+        protected static string [] scopesCalendar = 
+        { "https://www.googleapis.com/auth/calendar",
+          "https://www.googleapis.com/auth/calendar.events"
+        };
+        private string _ApiKey;
+        private IAuthorizationCodeFlow _flow;
+        ApplicationDbContext _dbContext;
+
+        IDataStore _dataStore;
+        ILogger _logger;
+        string _client_id;
+        string _client_secret; 
+
+        public CalendarManager(
+        ApplicationDbContext dbContext,
+        IDataStore dataStore,
+        ILoggerFactory loggerFactory,
+        IOptions<GoogleAuthSettings> settings)
+        {
+          _client_id = Startup.GoogleWebClientConfiguration["web:cient_id"];
+          _client_secret = Startup.GoogleWebClientConfiguration["web:cient_secret"];
+
+            _ApiKey = settings.Value.ApiKey;
+            _dbContext = dbContext;
+            _logger = loggerFactory.CreateLogger<CalendarManager>();
+            _dataStore = dataStore;
+            _flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
+                {
+                    ClientSecrets = new ClientSecrets
+                    {
+                        ClientId = _client_id,
+                        ClientSecret = _client_secret
+                    },
+                    Scopes = scopesCalendar ,
+                    DataStore = dataStore
+                });
+        }
+
+        /// <summary>
+        /// The get cal list URI.
+        /// </summary>
+        protected static string getCalListUri = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
+        /// <summary>
+        /// The get cal entries URI.
+        /// </summary>
+        protected static string getCalEntriesUri = "https://www.googleapis.com/calendar/v3/calendars/{0}/events";
+
+        /// <summary>
+        /// Gets the calendar list.
+        /// </summary>
+        /// <returns>The calendars.</returns>
+        /// <param name="userId">Yavsc user id</param>
+        public async Task<CalendarList> GetCalendarsAsync(string userId, string pageToken)
+        {
+            if (string.IsNullOrWhiteSpace(userId))
+                throw new Exception("the user id is not specified");
+			var service = await CreateUserCalendarServiceAsync(userId);
+#if Debug
+      if (service==null) throw new Exception("Could not get service");
+#endif
+      _logger.LogInformation("Got a service");
+
+#if Debug
+      if (service.CalendarList==null) throw new Exception("Could not get calendar list");
+#endif
+			CalendarListResource.ListRequest calListReq = service.CalendarList.List ();
+
+#if Debug
+      if (calListReq==null) throw new Exception ("list is null");
+#endif
+
+      calListReq.PageToken = pageToken;
+			return calListReq.Execute ();
+        }
+        
+        /// <summary>
+        /// Gets a calendar event list, between the given dates.
+        /// </summary>
+        /// <returns>The calendar.</returns>
+        /// <param name="calid">Calendar identifier.</param>
+        /// <param name="mindate">Mindate.</param>
+        /// <param name="maxdate">Maxdate.</param>
+        /// <param name="cred">credential string.</param>
+        public async Task<Events> GetCalendarAsync(string calid, DateTime minDate, DateTime maxDate, string pageToken)
+        {
+            var service = await GetServiceAsync();
+
+            var listRequest = service.Events.List(calid);
+            listRequest.PageToken = pageToken;
+            listRequest.TimeMin = minDate;
+            listRequest.TimeMax = maxDate;
+            listRequest.SingleEvents = true;
+            return await listRequest.ExecuteAsync();
+        }
+        public async Task<DateTimeChooserViewModel> CreateViewModelAsync(
+            string inputId,
+            string calid, DateTime mindate, DateTime maxdate)
+        {
+            if (calid == null)
+                return new DateTimeChooserViewModel
+                {
+                    InputId = inputId,
+                    MinDate = mindate,
+                    MaxDate = maxdate
+                };
+
+            var eventList = await GetCalendarAsync(calid, mindate, maxdate, null);
+            List<Period> free = new List<Period>();
+            List<Period> busy = new List<Period>();
+
+            foreach (var ev in eventList.Items)
+            {
+                if (ev.Start.DateTime.HasValue && ev.End.DateTime.HasValue ) {
+                DateTime start = ev.Start.DateTime.Value;
+                DateTime end = ev.End.DateTime.Value;
+
+                if (ev.Transparency == "transparent")
+                {
+
+                    free.Add(new Period { Start = start, End = end });
+                }
+                else busy.Add(new Period { Start = start, End = end });
+                }
+            }
+
+            return new DateTimeChooserViewModel
+            {
+                InputId = inputId,
+                MinDate = mindate,
+                MaxDate = maxdate,
+                Free = free.ToArray(),
+                Busy = busy.ToArray(),
+                FreeDates = free.SelectMany(p => new string[] { p.Start.ToString("dd/MM/yyyy HH:mm"), p.End.ToString("dd/MM/yyyy HH:mm") }).Distinct().ToArray(),
+                BusyDates = busy.SelectMany(p => new string[] { p.Start.ToString("dd/MM/yyyy HH:mm"), p.End.ToString("dd/MM/yyyy HH:mm") }).Distinct().ToArray()
+            };
+        }
+
+        /// <summary>
+        /// Creates a event in a calendar
+        /// <c>calendar.events.insert</c>
+        /// </summary>
+        /// <param name="calid"></param>
+        /// <param name="startDate"></param>
+        /// <param name="lengthInSeconds"></param>
+        /// <param name="summary"></param>
+        /// <param name="description"></param>
+        /// <param name="location"></param>
+        /// <param name="available"></param>
+        /// <returns></returns>
+        public async Task<Event> CreateEventAsync(string userId, string calid, DateTime startDate, int lengthInSeconds, string summary, string description, string location, bool available)
+        {
+
+            if (string.IsNullOrWhiteSpace(calid))
+                throw new Exception("the calendar identifier is not specified");
+            
+            var service = await GetServiceAsync();
+            Event ev = new Event
+            {
+                Start = new EventDateTime { DateTime = startDate },
+                End = new EventDateTime { DateTime = startDate.AddSeconds(lengthInSeconds) },
+                Summary = summary,
+                Description = description
+            };
+            var insert = service.Events.Insert(ev, calid);
+            var inserted = await insert.ExecuteAsync();
+
+            return inserted;
+        }
+        CalendarService _service = null;
+        public async Task<CalendarService> GetServiceAsync()
+        {
+            if (_service==null) {
+                GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync();
+                var baseClientService = new BaseClientService.Initializer()
+                    {
+                        HttpClientInitializer = credential
+                    };
+                if (credential.IsCreateScopedRequired)
+                {
+                    credential = credential.CreateScoped( scopesCalendar );
+                }/* 
+                var credential = await GoogleHelpers.GetCredentialForApi(new string [] { scopeCalendar });
+                if (credential.IsCreateScopedRequired)
+                {
+                    credential = credential.CreateScoped(scopeCalendar);
+                }
+                _service = new CalendarService(new BaseClientService.Initializer()
+                {
+                    HttpClientInitializer = credential,
+                    ApplicationName = "Yavsc"
+                });
+                }*/
+                _service = new CalendarService(new BaseClientService.Initializer()
+                    {
+                        HttpClientInitializer = credential,
+                        ApplicationName = "Yavsc"
+                    });
+            }
+            return _service;
+        }
+
+		/// <summary>
+		/// Creates Google User Credential
+		/// </summary>
+		/// <param name="userId">Yavsc use id</param>
+		/// <returns></returns>
+        public async Task<CalendarService> CreateUserCalendarServiceAsync(string userId)
+        {
+            GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync();
+
+            if (credential.IsCreateScopedRequired)
+            {
+                credential = credential.CreateScoped( scopesCalendar);
+            }
+
+
+            var service = new CalendarService(new BaseClientService.Initializer()
+            {
+                HttpClientInitializer = credential,
+                ApplicationName = "yavsc-001"
+            });
+
+			return service; 
+		}
+
+        public async Task<TokenResponse> RefreshToken(TokenResponse oldResponse)
+        {
+            string ep = " https://www.googleapis.com/oauth2/v4/token";
+            _logger.LogInformation($"rt:{oldResponse.RefreshToken}");
+            // refresh_token client_id client_secret grant_type=refresh_token
+            try {
+                using (var m = new SimpleJsonPostMethod(ep)) {
+                    return await m.Invoke<TokenResponse>(
+                        new { refresh_token= oldResponse.RefreshToken, client_id=_client_id,
+                         client_secret=_client_secret,
+                          grant_type="refresh_token" }
+                    );
+                }
+            }
+            catch (Exception ex) {
+                throw new Exception ("Quelque chose s'est mal passé à l'envoi",ex);
+            }
+        }
+    }
+}

src/Yavsc/Services/GoogleApis/Translate.cs

@@ -0,0 +1,60 @@
+using Yavsc.Server;
+using GoogleTranslateNET;
+using System;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.OptionsModel;
+using Microsoft.AspNet.Localization;
+using System.Linq;
+
+namespace Yavsc.Services.GoogleApis
+{
+    public class  Translator : ITranslator
+    {
+        GoogleTranslate _gg;
+        ILogger _logger;
+
+        public Translator(ILoggerFactory loggerFactory, 
+        IOptions<RequestLocalizationOptions> rqLocOptions, 
+        IOptions<GoogleAuthSettings> gSettings)
+        {
+             _gg = new GoogleTranslate(gSettings.Value.ApiKey);
+             _logger = loggerFactory.CreateLogger<Translator>();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="lang"></param>
+        /// <returns></returns>
+        static Language GetLanguageFromCountryCode(string lang)
+        {
+            switch (lang) {
+                case "fr":
+                case "fr-FR":
+                case "French":
+                return Language.French;
+              
+                case "en":
+                case "en-GB":
+                case "en-US":
+                case "English":
+                return Language.English;
+
+                case "pt":
+                case "br":
+                return Language.Portuguese;
+            }
+            return Language.Automatic;
+        }
+
+        public string[] Translate(string slang, string dlang, string[] text)
+        {
+            var destinationLanguage = GetLanguageFromCountryCode(dlang);
+            if (destinationLanguage == Language.Unknown)
+            throw new Exception ("destinationLanguage == Language.Unknown");
+            var sourceLanguage = GetLanguageFromCountryCode(slang);
+            var gResult = _gg.Translate(sourceLanguage, destinationLanguage, text);
+            return gResult.Select(tr => tr.TranslatedText).ToArray();
+        }
+    }
+}

src/Yavsc/Services/MailSender.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Threading.Tasks;
+using MailKit.Net.Smtp;
+using MailKit.Security;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.OptionsModel;
+using MimeKit;
+using Yavsc.Abstract.Manage;
+
+namespace Yavsc.Services
+{
+    public class MailSender : IEmailSender
+    {
+        private ILogger _logger;
+        SiteSettings siteSettings;
+        SmtpSettings smtpSettings;
+
+        public MailSender(
+            ILoggerFactory loggerFactory, 
+            IOptions<SiteSettings> sitesOptions, 
+            IOptions<SmtpSettings> smtpOptions,
+            IOptions<GoogleAuthSettings> googleOptions
+            )
+        {
+            _logger = loggerFactory.CreateLogger<MailSender>();
+            siteSettings = sitesOptions?.Value;
+            smtpSettings = smtpOptions?.Value;
+        }
+        
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="googleSettings"></param>
+        /// <param name="registrationId"></param>
+        /// <param name="ev"></param>
+        /// <returns>a MessageWithPayloadResponse,
+        /// <c>bool somethingsent = (response.failure == 0 &amp;&amp; response.success > 0)</c>
+        /// </returns>
+        
+
+        public async Task<EmailSentViewModel> SendEmailAsync(string username, string email, string subject, string message)
+        {
+            EmailSentViewModel model = new EmailSentViewModel{ EMail = email };
+            try
+            {
+                MimeMessage msg = new MimeMessage();
+                msg.From.Add(new MailboxAddress(
+                    siteSettings.Owner.Name,
+                siteSettings.Owner.EMail));
+                msg.To.Add(new MailboxAddress(username, email));
+                msg.Body = new TextPart("plain")
+                {
+                    Text = message
+                };
+                msg.Subject = subject;
+                msg.MessageId = MimeKit.Utils.MimeUtils.GenerateMessageId(
+                    siteSettings.Authority
+                );
+                using (SmtpClient sc = new SmtpClient())
+                {
+                    sc.Connect(
+                        smtpSettings.Host,
+                        smtpSettings.Port,
+                        SecureSocketOptions.None);
+                    await sc.SendAsync(msg);
+                    model.MessageId = msg.MessageId;
+                    model.Sent = true; // a duplicate info to remove from the view model, that equals to MessageId == null
+                }
+            }
+            catch (Exception ex)
+            {
+                model.Sent = false;
+                model.ErrorMessage = ex.Message;
+                return model;
+            }
+            return model;
+        }
+
+    }
+}

src/Yavsc/Services/MessageServices.cs

@@ -0,0 +1,8 @@
+
+namespace Yavsc.Services
+{
+    // This class is used by the application to send Email and SMS
+    // when you turn on two-factor authentication in ASP.NET Identity.
+    // For more details see this link http://go.microsoft.com/fwlink/?LinkID=532713
+
+}

src/Yavsc/Services/SIRENCheker.cs

@@ -0,0 +1,22 @@
+using System.Net.Http;
+using System.Threading.Tasks;
+using Yavsc.Helpers;
+
+namespace Yavsc.Services
+{
+    using Models.societe.com;
+    public class SIRENChecker
+    {
+        private CompanyInfoSettings _settings;
+        public SIRENChecker(CompanyInfoSettings settings)
+        {
+            _settings = settings;
+        }
+        public async Task<CompanyInfoMessage> CheckAsync(string siren) {
+             using (var web = new HttpClient())
+                {
+                   return await web.CheckSiren(siren, _settings);
+                }
+        }
+    }
+}