public ActionResult Create(User user)
{
try
{
if (!ModelState.IsValid)
{
return(View(user));
}
if (CredentialsRepository.busyUsername(user.Username))
{
ModelState.AddModelError("Username", "El usuario ya está ocupado, intente otro por favor.");
return(View(user));
}
if (CredentialsRepository.busyEmail(user.Email))
{
ModelState.AddModelError("Email", "El Email ya está ocupado, intente otro por favor.");
return(View(user));
}
UserRepository.StoreUser(user);
TempData["Message"] = string.Format(" {0} creado correctamente ", user.Username);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
TempData["Message"] = string.Format(" Ocurrio el error -> {0} || intente nuevamente", e.Message);
return(RedirectToAction("Index"));
}
}
public static void LogIntoInstagram()
{
var loginCredentials = CredentialsRepository.ReadCredentials();
var webDriver = WebDriverProvider.WebDriver;
webDriver.Navigate().GoToUrl(new Uri("https://www.instagram.com/accounts/login/"));
ThreadDelayer.WaitSomeTime();
AcceptCookies(webDriver);
ThreadDelayer.WaitSomeTime();
var userName = webDriver.FindElement(By.Name("username"));
var password = webDriver.FindElement(By.Name("password"));
userName.InsertText(loginCredentials.Username);
ThreadDelayer.WaitSomeTime(WaitingPeriod.Short);
password.InsertText(loginCredentials.Password);
ThreadDelayer.WaitSomeTime(WaitingPeriod.Short);
var loginButton = webDriver.FindElements(By.TagName("button")).First(x => x.Text.ToLower() == "log in");
loginButton.Submit();
ThreadDelayer.WaitSomeTime(WaitingPeriod.Short);
ThreadDelayer.WaitSomeTime();
}
public UnitOfWork(bbuContext context)
{
_context = context;
Addresses = new AddressRepository(_context);
AppUsers = new AppUserRepository(_context);
Banks = new BankRepository(_context);
BankAccounts = new BankAccountRepository(_context);
Cemeteries = new CemeteryRepository(_context);
Credentials = new CredentialsRepository(_context);
Deceaseds = new DeceasedRepository(_context);
Doctors = new DoctorRepository(_context);
Employees = new EmployeeRepository(_context);
Files = new FileRepository(_context);
Funerals = new FuneralRepository(_context);
FuneralDocuments = new FuneralDocumentRepository(_context);
Genders = new GenderRepository(_context);
HomeAffairsOffices = new HomeAffairsOfficeRepository(_context);
HomeAffairsOfficers = new HomeAffairsOfficerRepository(_context);
Hospitals = new HospitalRepository(_context);
Informants = new InformantRepository(_context);
Members = new MemberRepository(_context);
Months = new MonthRepository(_context);
Mortuaries = new MortuaryRepository(_context);
NextOfKins = new NextOfKinRepository(_context);
NumberConfigurations = new NumberConfigurationRepository(_context);
Payments = new PaymentRepository(_context);
PaymentPeriods = new PaymentPeriodRepository(_context);
People = new PersonRepository(_context);
PurchaseItems = new PurchaseItemRepository(_context);
Settings = new SettingRepository(_context);
States = new StateRepository(_context);
Suppliers = new SupplierRepository(_context);
Tasks = new TaskRepository(_context);
Years = new YearRepository(_context);
}
public Spotify(IHttpClientFactory httpClientFactory, IConfiguration configuration, ILogger <Spotify> logger, CredentialsRepository credentialsRepository)
{
_httpClientFactory = httpClientFactory;
_logger = logger;
_credentialsRepository = credentialsRepository;
_configs = configuration.GetSection("Spotify");
}
public UnitOfWork(XdContext context)
{
_context = context;
AddressInformations = new AddressInformationRepository(_context);
AppUsers = new AppUserRepository(_context);
AppUserRoles = new AppUserRoleRepository(_context);
Contacts = new ContactRepository(_context);
Credentials = new CredentialsRepository(_context);
DbTypes = new DbTypeRepository(_context);
Entities = new EntityRepository(_context);
EntityTypes = new EntityTypeRepository(_context);
Fields = new FieldRepository(_context);
FieldRequirementLevels = new FieldRequirementLevelRepository(_context);
FieldTypes = new FieldTypeRepository(_context);
Forms = new FormRepository(_context);
FormTypes = new FormTypeRepository(_context);
Genders = new GenderRepository(_context);
MaritalStatuses = new MaritalStatusRepository(_context);
MenuItems = new MenuItemRepository(_context);
Roles = new RoleRepository(_context);
Tabs = new TabRepository(_context);
Titles = new TitleRepository(_context);
Views = new ViewRepository(_context);
ViewTypes = new ViewTypeRepository(_context);
}
public AccountService() : base()
{
this.CredentialsRepository = new CredentialsRepository(
this.UsersRepository.GetExistingDatabaseContext());
this.ArchiveRepository = new ArchiveRepository(
this.UsersRepository.GetExistingDatabaseContext());
}
public static void StoreUser(User user)
{
ctx = new CheqStoreContext();
user.Password = CredentialsRepository.EncryptingPassword(user.Password);
ctx.Users.Add(user);
ctx.SaveChanges();
}
public PayoutProcess(
CredentialsRepository connectionRepository,
ShopifyPayoutPullWorker shopifyPayoutPullWorker,
BankImportService bankImportService,
ShopifyPayoutRepository persistenceRepository)
{
_connectionRepository = connectionRepository;
_shopifyPayoutPullWorker = shopifyPayoutPullWorker;
_bankImportService = bankImportService;
_persistenceRepository = persistenceRepository;
}
public static Credentials GetLoginData()
{
var credentials = CredentialsRepository.ReadCredentials();
if (credentials == null)
{
credentials = GetCredentialsFromUser();
}
return(credentials);
}
/// <summary>
/// Load stored credentials from phone
/// </summary>
private void LoadCredentials()
{
ICredentials credentials = CredentialsRepository.Load();
if (credentials.RememberMe)
{
Email = credentials.Email;
Password = credentials.Password;
RememberMe = credentials.RememberMe;
}
}
public AddCredentialsForm(CredentialsRepository credentialsRepository,
PasswordManagerGroupsProvider passwordManagerGroupsProvider,
PasswordGenerator passwordGenerator)
{
this.credentialsRepository = credentialsRepository;
this.passwordManagerGroupsProvider = passwordManagerGroupsProvider;
this.passwordGenerator = passwordGenerator;
InitializeComponent();
Translator.Translate(this);
toolTip.SetToolTip(btnGenerate, Lng.Elem("Generate"));
}
/// <summary>
/// Save credentials to phone
/// </summary>
private void SaveCredentials()
{
ICredentials credentials = new Credentials();
if (RememberMe)
{
credentials.Email = Email;
credentials.Password = Password;
credentials.RememberMe = RememberMe;
}
CredentialsRepository.Save(credentials);
}
public void NotifyUserOnRegistration_Integration_EmailSent()
{
using (var fixture = new FixtureInit("http://localhost"))
{
// assert
var credentialsRepository = new CredentialsRepository(fixture.Setup.Context);
var credentialService = new CredentialsService(credentialsRepository);
var emailService = new EmailService(credentialService);
var notificationService = new NotificationService(emailService);
// act / assert
notificationService.NotifyUserOnRegistration("*****@*****.**", "password");
}
}
public AuthController(IOptions <JwtIssuerOptions> jwtOptions,
ILogger <AuthController> logger,
CredentialsRepository credentialsRepository)
{
_jwtOptions = jwtOptions.Value;
_logger = logger;
_credentialsRepository = credentialsRepository;
_serializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented
};
}
public ShopifyPayoutPullWorker(
CredentialsRepository connectionRepository,
ShopifyBatchRepository shopifyBatchRepository,
ShopifyPayoutRepository persistRepository,
SettingsRepository settingsRepository,
PayoutApi payoutApi,
IPushLogger logger)
{
_connectionRepository = connectionRepository;
_shopifyBatchRepository = shopifyBatchRepository;
_persistRepository = persistRepository;
_settingsRepository = settingsRepository;
_payoutApi = payoutApi;
_logger = logger;
}
public void Credentials_GetCredentials()
{
using (var fixture = new FixtureInit("http://localhost"))
{
// arrange
var repository = new CredentialsRepository(fixture.Setup.Context);
// act
var credentials = repository.Credentials;
// assert
Assert.That(credentials, Is.Not.Null);
Assert.That(credentials.Count(), Is.EqualTo(0), "No credentials set in initial database.");
}
}
private static Credentials GetCredentialsFromUser()
{
var loginInfo = GetLoginInfo();
var credentials = new Credentials
{
Username = loginInfo.Username,
Password = loginInfo.Password
};
if (loginInfo.PersistCredentials)
{
CredentialsRepository.SaveCredentials(credentials);
}
return(credentials);
}
public PasswordManager(AddCredentialsForm addCredentialsForm,
CredentialsProvider credentialsProvider,
CredentialsRepository credentialsRepository,
ClipboardHelper clipboardHelper,
ProcessUtils processUtils,
PasswordManagerGroupsProvider passwordManagerGroupsProvider)
{
this.addCredentialsForm = addCredentialsForm;
this.credentialsProvider = credentialsProvider;
this.clipboardHelper = clipboardHelper;
this.processUtils = processUtils;
this.credentialsRepository = credentialsRepository;
this.passwordManagerGroupsProvider = passwordManagerGroupsProvider;
InitializeComponent();
Translator.Translate(this);
}
/// <summary>
/// Attempts authentication using the given credentials.
/// </summary>
/// <param name="enteredCredentials">Entered credentials.</param>
public virtual AuthenticationResult Authenticate(TEnteredCredentials enteredCredentials)
{
if (enteredCredentials == null)
{
throw new ArgumentNullException(nameof(enteredCredentials));
}
var storedCredentials = CredentialsRepository.GetStoredCredentials(enteredCredentials);
if (storedCredentials == null)
{
return(new AuthenticationResult(false, false));
}
var verified = CredentialsVerifier.Verify(enteredCredentials, storedCredentials);
return(new AuthenticationResult(true, verified));
}
public async Task CredentialsFileCreatedAndDeletedTest()
{
CredentialsRepository credentialsRepository = new CredentialsRepository();
var credentials = new Credentials
{
UserName = "******",
Password = "******"
};
await credentialsRepository.SaveCredentialsAsync(credentials).ConfigureAwait(false);
Assert.IsTrue(System.IO.File.Exists(_filePath));
credentialsRepository.Dispose();
Assert.IsFalse(System.IO.File.Exists(_filePath));
}
/// <summary>
/// Procesa el Login para poder comparar las credenciales y dar o no acceso cargandolo en la sesion.
/// Here below process the login to comparing the credentials and give or not access in the current session
/// </summary>
/// <param name="loginClass"></param>
/// <returns> string</returns>
public static ResponseEntity ProccessingLogin(LoginClass loginClass, string rol = "Cliente")
{
if (loginClass == null)
{
return responseEntity = new ResponseEntity()
{
status = false, message = "El login no puede ser nulo"
}
}
;
//Here I compare the credentials with encrypting password
string EncryptingPassword = CredentialsRepository.EncryptingPassword(loginClass.Password);
User credentials;
if (rol == "Cliente")
{
credentials = ctx.Users.FirstOrDefault(x => x.Username == loginClass.Username && x.Password == EncryptingPassword && x.Rol.ToString() == rol);
}
else
{
credentials = ctx.Users.FirstOrDefault(x => x.Username == loginClass.Username && x.Password == EncryptingPassword && x.Rol.ToString() != "Cliente");
}
if (credentials == null)
{
return responseEntity = new ResponseEntity()
{
status = false, message = "Los datos no coinciden, por favor revisar"
}
}
;
CredentialsRepository.CreateSession(credentials.Username);
return(responseEntity = new ResponseEntity()
{
status = true, message = ""
});
}
}
}
public async Task CredentialsIsRetunedTest()
{
CredentialsRepository credentialsRepository = new CredentialsRepository();
var credentials = new Credentials
{
UserName = "******",
Password = "******"
};
await credentialsRepository.SaveCredentialsAsync(credentials).ConfigureAwait(false);
Assert.IsTrue(System.IO.File.Exists(_filePath));
var credentialsFromFile = await credentialsRepository.GetCredentialsAsync().ConfigureAwait(false);
Assert.AreEqual(credentials.UserName, credentialsFromFile.UserName);
Assert.AreEqual(credentials.Password, credentialsFromFile.Password);
}
public InstanceContext(
MasterRepository systemRepository,
ProcessPersistContext processPersistContext,
MiscPersistContext miscPersistContext,
CredentialsRepository connectionRepository,
SettingsRepository settingsRepository,
ShopifyHttpContext shopifyHttpContext,
StateRepository stateRepository,
AcumaticaHttpContext acumaticaHttpContext)
{
_connectionRepository = connectionRepository;
_settingsRepository = settingsRepository;
_systemRepository = systemRepository;
_processPersistContext = processPersistContext;
_miscPersistContext = miscPersistContext;
_shopifyHttpContext = shopifyHttpContext;
_stateRepository = stateRepository;
_acumaticaHttpContext = acumaticaHttpContext;
}
public ActionResult Index(RegisterRequest registerRequest)
{
if (registerRequest == null)
{
ViewBag.Message = "No puede ser nulo el registro"; return(View());
} //Devuelvo la vista.
var StoreRegister = RegisterRepository.StoreRegister(registerRequest);
if (StoreRegister.status)
{
CredentialsRepository.CreateSession(registerRequest.Username);
return(RedirectToAction("Index", "Products"));
}
ViewBag.Message = StoreRegister.message;
return(View());
}
public BackgroundAlertService(
SlackAPI slackAPI,
IUserTimesRepository userPreferences,
CredentialsRepository credentials,
ISubscriberRepository subscriberRepository,
MonthlyDataRepository monthlyDataRepository,
UserRecordService userRecordService)
{
this.slackAPI = slackAPI;
this.userPreferences = userPreferences;
this.subscriberRepository = subscriberRepository;
this.monthlyDataRepository = monthlyDataRepository;
this.userRecordService = userRecordService;
this.credentials = credentials;
currentTime = Utilities.CalculateSeconds(DateTime.Now);
var time = DateTime.Now;
firstOfMonth = time.Day == Constants.reportDay ? new DateTimeOffset(Utilities.NextReportDate(time)).ToUnixTimeSeconds() : new DateTimeOffset(Utilities.NextReportDate(time.AddMonths(1))).ToUnixTimeSeconds();
}
public ShopifyAuthController(
OAuthApi oAuthApi,
CredentialsRepository connectionRepository,
InstanceContext connectionContext,
ShopifyHttpContext shopifyHttpContext,
IdentityService identityService,
StateRepository stateRepository,
HmacCryptoService hmacCrypto,
ProvisioningService provisioningService,
IPushLogger logger)
{
_provisioningService = provisioningService;
_identityService = identityService;
_oAuthApi = oAuthApi;
_connectionRepository = connectionRepository;
_connectionContext = connectionContext;
_shopifyHttpContext = shopifyHttpContext;
_stateRepository = stateRepository;
_hmacCrypto = hmacCrypto;
_logger = logger;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var bus = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri("amqp://*****:*****@dove.rmq.cloudamqp.com/hwtjwzhp"), h =>
{
h.Username("hwtjwzhp");
h.Password("AgmGeD5PSuocVNMgot9OncI595wDL7Uv");
});
});
bus.Start();
var userRepository = new CredentialsRepository();
var eventRepository = new EventRepository();
var eventService = new EventServices(bus, eventRepository);
services.AddSingleton <ICredentialsRepository>(userRepository);
services.AddSingleton <IEventRepository>(eventRepository);
services.AddSingleton <IEventServices>(eventService);
services.AddControllersWithViews();
}
public bool ValidateUser(string username, string password, int apiEwId = 0)
{
var isValid = false;
ApiEw apiEw = null;
EarthwatcherRepository earthwatcherRepo = new EarthwatcherRepository(connectionString);
if (apiEwId != 0)
{
apiEw = earthwatcherRepo.GetApiEwById(apiEwId);
}
if (apiEw == null)
{
var credentials = CredentialsRepository.GetCredentials(connectionString, username);
isValid = PasswordChecker.CheckPassword(password, credentials.Prefix, credentials.Hash);
}
else
{
//TODO: Validacion de AccessToken, por ahora si entro con una api lo manda derecho
isValid = true;
}
return(isValid);
}
static void Main(string[] args)
{
Console.WriteLine("Trackyt.net - upgrade for v.1.0.1.\nNotify all users about password remove.\n");
try
{
// repositories
var usersRepository = new UsersRepository();
var credentialsRepository = new CredentialsRepository();
// services
var credentialService = new CredentialsService(credentialsRepository);
var emailService = new EmailService(credentialService);
SendEmailNotificationsToUsers(usersRepository, emailService);
}
catch (Exception e)
{
Console.WriteLine("User notification failed!");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
public static ResponseEntity StoreRegister(RegisterRequest registerRequest)
{
if (CredentialsRepository.busyUsername(registerRequest.Username))
{
return responseEntity = new ResponseEntity()
{
status = false, message = "El usuario ya está ocupado, pruebe con otro por favor"
}
}
;
try
{
User userEntity = new User()
{
Name = registerRequest.Name,
Username = registerRequest.Username,
Password = CredentialsRepository.EncryptingPassword(registerRequest.Password),
};
ctx.Users.Add(userEntity);
ctx.SaveChanges();
return(responseEntity = new ResponseEntity()
{
status = true, message = ""
});
}
catch (Exception e)
{
return(responseEntity = new ResponseEntity()
{
status = false, message = "Error al grabar el usuario desde register, -> " + e.Message
});
}
}
}
