public ConfigurationParser(ConfigurationTypeEnum configurationType, string fileName = null)
{
_environmentVariableRepository = new EnvironmentVariableRepository(
new EnvironmentVariableSource(),
new FileVariableSource(configurationType, fileName),
configurationType);
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app, IComponentContext context)
{
_environmentVariable = context.Resolve <IEnvironmentVariableRepository>();
_oAuthLoginRepository = context.Resolve <IOAuthLoginRepository>();
_stringConstantRepository = context.Resolve <IStringConstantRepository>();
_redirectUrl = string.Format("{0}{1}", AppSettingUtil.PromactErpUrl, _stringConstantRepository.RedirectUrl);
// Configure the db context, user manager and signin manager to use a single instance per request
app.CreatePerOwinContext(PromactErpContext.Create);
app.CreatePerOwinContext <ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext <ApplicationSignInManager>(ApplicationSignInManager.Create);
JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary <string, string>();
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = _stringConstantRepository.AuthenticationType
});
app.UseOpenIdConnectAuthentication(new OpenIdConnectAuthenticationOptions
{
Authority = AppSettingUtil.OAuthUrl,
ClientId = _environmentVariable.PromactOAuthClientId,
ClientSecret = _environmentVariable.PromactOAuthClientSecret,
RedirectUri = _redirectUrl,
TokenValidationParameters = new TokenValidationParameters
{
NameClaimType = _stringConstantRepository.NameClaimType,
RoleClaimType = _stringConstantRepository.RoleClaimType
},
ResponseType = _stringConstantRepository.ResponseType,
Scope = _stringConstantRepository.Scope,
SignInAsAuthenticationType = _stringConstantRepository.AuthenticationType,
AuthenticationType = _stringConstantRepository.AuthenticationTypeOidc,
PostLogoutRedirectUri = AppSettingUtil.PromactErpUrl,
UseTokenLifetime = true,
Notifications = new OpenIdConnectAuthenticationNotifications
{
SecurityTokenReceived = async tokenReceived =>
{
var accessToken = tokenReceived.ProtocolMessage.AccessToken;
var discovery = new DiscoveryClient(AppSettingUtil.OAuthUrl);
discovery.Policy.RequireHttps = false;
var doc = await discovery.GetAsync();
var userInfoClient = new UserInfoClient(doc.UserInfoEndpoint);
var user = await userInfoClient.GetAsync(accessToken);
var tokenClient = new TokenClient(doc.TokenEndpoint, _environmentVariable.PromactOAuthClientId, _environmentVariable.PromactOAuthClientSecret);
var response = await tokenClient.RequestAuthorizationCodeAsync(tokenReceived.ProtocolMessage.Code, _redirectUrl);
var refreshToken = response.RefreshToken;
string userId = user.Claims.ToList().Single(x => x.Type == _stringConstantRepository.Sub).Value;
string email = user.Claims.ToList().Single(x => x.Type == _stringConstantRepository.Email).Value;
await _oAuthLoginRepository.AddNewUserFromExternalLoginAsync(email, refreshToken, userId);
},
AuthenticationFailed = authenticationFailed =>
{
authenticationFailed.Response.Redirect("/"); //redirect to home page.
authenticationFailed.HandleResponse();
return(Task.FromResult(0));
},
}
});
}
public HomeController(ApplicationUserManager userManager, IStringConstantRepository stringConstant, ApplicationSignInManager signInManager, ILogger logger, IOAuthLoginRepository oAuthLoginRepository, IEnvironmentVariableRepository envVariableRepository)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_oAuthLoginRepository = oAuthLoginRepository;
_envVariableRepository = envVariableRepository;
_stringConstant = stringConstant;
}
public Client(IProjectUserCallRepository projectUser, IStringConstantRepository stringConstant, IEmailService email, IAttachmentRepository attachmentRepository, IHttpClientRepository httpClientRepository, IEnvironmentVariableRepository envVariableRepository)
{
_chatUpdateMessage = new HttpClient();
_chatUpdateMessage.BaseAddress = new Uri(_stringConstant.SlackChatUpdateUrl);
_projectUser = projectUser;
_email = email;
_stringConstant = stringConstant;
_attachmentRepository = attachmentRepository;
_httpClientRepository = httpClientRepository;
_envVariableRepository = envVariableRepository;
}
public OAuthLoginRepositoryTest()
{
_componentContext = AutofacConfig.RegisterDependancies();
_oAuthLoginRepository = _componentContext.Resolve <IOAuthLoginRepository>();
_attachmentRepository = _componentContext.Resolve <IAttachmentRepository>();
_slackUserRepository = _componentContext.Resolve <ISlackUserRepository>();
_slackChannelRepository = _componentContext.Resolve <ISlackChannelRepository>();
_mockHttpClient = _componentContext.Resolve <Mock <IHttpClientRepository> >();
_envVariableRepository = _componentContext.Resolve <IEnvironmentVariableRepository>();
_stringConstant = _componentContext.Resolve <IStringConstantRepository>();
Initialize();
}
public HomeController(ApplicationUserManager userManager, IStringConstantRepository stringConstant,
ApplicationSignInManager signInManager, IOAuthLoginRepository oAuthLoginRepository,
IEnvironmentVariableRepository envVariableRepository, IMd5Service md5Service, IGroupRepository groupRepository) : base(stringConstant)
{
_userManager = userManager;
_signInManager = signInManager;
_oAuthLoginRepository = oAuthLoginRepository;
_envVariableRepository = envVariableRepository;
_logger = LogManager.GetLogger("AuthenticationModule");
_md5Service = md5Service;
_groupRepository = groupRepository;
}
public OAuthLoginRepository(ApplicationUserManager userManager,
IHttpClientRepository httpClientRepository, IRepository <SlackUserDetails> slackUserDetails,
IRepository <SlackChannelDetails> slackChannelDetails, IStringConstantRepository stringConstant,
ISlackUserRepository slackUserRepository, IEnvironmentVariableRepository envVariableRepository)
{
_userManager = userManager;
_httpClientRepository = httpClientRepository;
_slackUserDetails = slackUserDetails;
_stringConstant = stringConstant;
_slackUserRepository = slackUserRepository;
_slackChannelDetails = slackChannelDetails;
_envVariableRepository = envVariableRepository;
}
public Bot(ITaskMailRepository taskMailRepository,
ISlackUserRepository slackUserDetailsRepository,
IStringConstantRepository stringConstant,
IEnvironmentVariableRepository environmentVariableRepository, IComponentContext component)
{
_taskMailRepository = taskMailRepository;
_slackUserDetailsRepository = slackUserDetailsRepository;
_logger = LogManager.GetLogger("TaskBotModule");
_scrumlogger = LogManager.GetLogger("ScrumBotModule");
_stringConstant = stringConstant;
_environmentVariableRepository = environmentVariableRepository;
_component = component;
}
/// <summary>
/// Used to connect task mail bot and to capture task mail
/// </summary>
/// <param name="container"></param>
public static void Main(IComponentContext container)
{
_logger = container.Resolve <ILogger>();
_stringConstant = container.Resolve <IStringConstantRepository>();
try
{
_taskMailRepository = container.Resolve <ITaskMailRepository>();
_slackUserDetails = container.Resolve <ISlackUserRepository>();
_environmentVariableRepository = container.Resolve <IEnvironmentVariableRepository>();
// assigning bot token on Slack Socket Client
string botToken = _environmentVariableRepository.TaskmailAccessToken;
SlackSocketClient client = new SlackSocketClient(botToken);
// Creating a Action<MessageReceived> for Slack Socket Client to get connect. No use in task mail bot
MessageReceived messageReceive = new MessageReceived();
messageReceive.ok = true;
Action <MessageReceived> showMethod = (MessageReceived messageReceived) => new MessageReceived();
// Telling Slack Socket Client to the bot whose access token was given early
client.Connect((connected) => { });
try
{
// Method will hit when someone send some text in task mail bot
client.OnMessageReceived += (message) =>
{
var user = _slackUserDetails.GetById(message.user);
string replyText = "";
var text = message.text;
if (text.ToLower() == _stringConstant.TaskMailSubject.ToLower())
{
replyText = _taskMailRepository.StartTaskMail(user.Name).Result;
}
else
{
replyText = _taskMailRepository.QuestionAndAnswer(user.Name, text).Result;
}
// Method to send back response to task mail bot
client.SendMessage(showMethod, message.channel, replyText);
};
}
catch (Exception)
{
client.CloseSocket();
}
}
catch (Exception ex)
{
_logger.Error(_stringConstant.LoggerErrorMessageTaskMailBot + " " + ex.Message + "\n" + ex.StackTrace);
throw ex;
}
}
/// <summary>
/// Used for Scrum meeting bot connection and to conduct scrum meeting
/// </summary>
/// <param name="container"></param>
public static void ScrumMain(IComponentContext container)
{
_logger = container.Resolve <ILogger>();
_stringConstant = container.Resolve <IStringConstantRepository>();
try
{
_environmentVariableRepository = container.Resolve <IEnvironmentVariableRepository>();
string botToken = _environmentVariableRepository.ScrumBotToken;
SlackSocketClient client = new SlackSocketClient(botToken);//scrumBot
_scrumBotRepository = container.Resolve <IScrumBotRepository>();
// Creating a Action<MessageReceived> for Slack Socket Client to get connected.
MessageReceived messageReceive = new MessageReceived();
messageReceive.ok = true;
Action <MessageReceived> showMethod = (MessageReceived messageReceived) => new MessageReceived();
//Connecting the bot of the given token
client.Connect((connected) => { });
// Method will be called when someone sends message
client.OnMessageReceived += (message) =>
{
_logger.Info("Scrum bot got message :" + message);
try
{
_logger.Info("Scrum bot got message, inside try");
string replyText = _scrumBotRepository.ProcessMessages(message.user, message.channel, message.text).Result;
if (!String.IsNullOrEmpty(replyText))
{
_logger.Info("Scrum bot got reply");
client.SendMessage(showMethod, message.channel, replyText);
}
}
catch (Exception ex)
{
_logger.Error("\n" + _stringConstant.LoggerScrumBot + " " + ex.Message + "\n" + ex.StackTrace);
client.CloseSocket();
throw ex;
}
};
//ChannelCreated channel = new ChannelCreated();
//client.HandleChannelCreated(channel);
}
catch (Exception ex)
{
_logger.Error("\n" + _stringConstant.LoggerScrumBot + " " + ex.Message + "\n" + ex.StackTrace);
throw ex;
}
}
public OAuthLoginRepository(ApplicationUserManager userManager,
IHttpClientService httpClientService, IRepository <SlackUserDetails> slackUserDetailsRepository,
IRepository <SlackChannelDetails> slackChannelDetailsRepository, IStringConstantRepository stringConstant,
ISlackUserRepository slackUserRepository, IEnvironmentVariableRepository envVariableRepository,
IRepository <IncomingWebHook> incomingWebHook, ISlackChannelRepository slackChannelRepository)
{
_userManager = userManager;
_httpClientService = httpClientService;
_slackUserDetailsRepository = slackUserDetailsRepository;
_stringConstant = stringConstant;
_slackUserRepository = slackUserRepository;
_slackChannelDetails = slackChannelDetailsRepository;
_envVariableRepository = envVariableRepository;
_incomingWebHookRepository = incomingWebHook;
_slackChannelRepository = slackChannelRepository;
_logger = LogManager.GetLogger("AuthenticationModule");
}
public Client(IOauthCallsRepository oauthCallRepository, IStringConstantRepository stringConstant,
IEmailService emailService, IAttachmentRepository attachmentRepository, IHttpClientService httpClientService,
IEnvironmentVariableRepository envVariableRepository, ISlackUserRepository slackUserRepository,
IEmailServiceTemplateRepository emailTemplateRepository, IRepository <IncomingWebHook> incomingWebHook,
ApplicationUserManager userManager, IMailSettingDetailsByProjectAndModuleRepository mailSettingDetails)
{
_stringConstant = stringConstant;
_oauthCallRepository = oauthCallRepository;
_emailService = emailService;
_attachmentRepository = attachmentRepository;
_httpClientService = httpClientService;
_envVariableRepository = envVariableRepository;
_slackUserRepository = slackUserRepository;
_emailTemplateRepository = emailTemplateRepository;
_incomingWebHook = incomingWebHook;
_userManager = userManager;
_mailSettingDetails = mailSettingDetails;
_logger = LogManager.GetLogger("ClientRepository");
}
public static T Parse <T>(IEnvironmentVariableRepository env)
{
var parser = new ConfigurationParser(env);
return(parser.ParseConfiguration <T>());
}
public ConfigurationParser(IEnvironmentVariableRepository environmentVariableRepository)
{
_environmentVariableRepository = environmentVariableRepository;
}
public EmailService(IEnvironmentVariableRepository envVariableRepository)
{
_envVariableRepository = envVariableRepository;
}
public EmailService(IEnvironmentVariableRepository envVariableRepository)
{
_envVariableRepository = envVariableRepository;
_logger = LogManager.GetLogger("EmailService");
}
public ServiceRepository(IEnvironmentVariableRepository environmentVariable)
{
_environmentVariable = environmentVariable;
}
