public static AccountDbContext CreateFromAccountIdLocalCache(Guid accountId)
{
var account = ConfigDbServicesHelper.GetAccountService().GetOneById(accountId);
var database = ConfigDbServicesHelper.GetDatabaseService().GetOneById(account.AccountDatabaseId);
return(CreateFromConnectionString(database.ConnectionString));
}
protected void SetAccountOverlimitSignal()
{
ConfigDbServicesHelper.GetAccountService().Update(new UpdateAccountRequestData()
{
Id = AccountId,
LastOverLimitDate = Now
});
}
public static Guid GetSystemAccountId()
{
if (_systemAccountId == null)
{
_systemAccountId = ConfigDbServicesHelper.GetAccountService().GetSystemAccount().Id;
}
return(_systemAccountId.Value);
}
public User FindUser(string login, string accountName)
{
AccountInfo account = null;
if (!string.IsNullOrEmpty(accountName))
{
account = ConfigDbServicesHelper.GetAccountService().GetOneOrNullBySystemName(accountName);
}
var logins = ConfigDbServicesHelper.GetLoginService().GetAllByLogin(login);
if (logins.Length == 0)
{
throw new WrongLoginException();
}
LoginInfo loginInfo;
if (logins.Length == 1)
{
loginInfo = logins[0];
if (account != null && account.Id != loginInfo.Account.Id)
{
throw new WrongLoginException();
}
}
else
{
if (account == null)
{
throw new AccountRequiredException();
}
loginInfo = logins.FirstOrDefault(t => t.Account.Id == account.Id);
if (loginInfo == null)
{
throw new WrongLoginException();
}
}
if (loginInfo.Account.Status != AccountStatus.Active)
{
throw new AccountIsBlockedException();
}
var accountContext = Context.GetAccountDbContext(loginInfo.Account.Id);
var userRepository = accountContext.GetUserRepository();
var user = userRepository.GetOneOrNullByLogin(login);
if (user == null)
{
throw new WrongLoginException();
}
return(user);
}
public static TestAccountInfo GetTestAccount()
{
var account = ConfigDbServicesHelper.GetAccountService().GetOneOrNullBySystemName("TEST");
if (account == null)
{
throw new Exception("Тестовый аккаунт не существует");
}
return(TestAccountInfo.Create(account));
}
public void SetUser(UserInfo user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
CurrentUser = user;
var accountId = user.AccountId;
CurrentAccount = ConfigDbServicesHelper.GetAccountService().GetOneById(accountId);
AccountDbContext = DbContext.GetAccountDbContextByDataBaseId(CurrentAccount.AccountDatabaseId);
}
public static Zidium.Api.AccessToken GetSystemToken()
{
if (_systemToken == null)
{
var account = ConfigDbServicesHelper.GetAccountService().GetSystemAccount();
_systemToken = new Zidium.Api.AccessToken()
{
SecretKey = account.SecretKey
};
}
return(_systemToken);
}
public ActionResult Index()
{
var account = ConfigDbServicesHelper.GetAccountService().GetSystemAccount();
var model = new ShowAccountModel()
{
Id = account.Id,
AccountName = account.SystemName,
SecretKey = account.SecretKey,
TariffName = AccountTypeHelper.GetDisplayName(account.Type),
AccountType = account.Type
};
return(View(model));
}
public void SendResetPasswordLetter(Guid accountId, Guid userId, Guid token)
{
var account = ConfigDbServicesHelper.GetAccountService().GetOneById(accountId);
var accountDbContext = Context.GetAccountDbContext(accountId);
var userRepository = accountDbContext.GetUserRepository();
var user = userRepository.GetById(userId);
var url = UrlHelper.GetPasswordSetUrl(accountId, token, account.SystemName);
var emailCommand = EmailMessageHelper.ResetPasswordLetter(user.Login, url);
emailCommand.ReferenceId = token;
var emailCommandRepository = accountDbContext.GetSendEmailCommandRepository();
emailCommandRepository.Add(emailCommand);
}
public AccountDbContext GetAccountDbContext(Guid accountId)
{
if (IsInternalDispatcherContext)
{
var account = ConfigDbServicesHelper.GetAccountService().GetOneById(accountId);
return(GetAccountDbContextByDataBaseId(account.AccountDatabaseId));
}
else
{
var client = DispatcherHelper.GetDispatcherClient();
var account = client.GetAccountById(new GetAccountByIdRequestData()
{
Id = accountId
}).Data;
return(GetAccountDbContextByDataBaseId(account.AccountDatabaseId));
}
}
public ActionResult Logon(LogonModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var accountName = GetAccountName();
var userService = new UserService(DbContext);
try
{
var authInfo = userService.Auth(model.UserName, model.Password, accountName);
var tokenService = new TokenService(DbContext);
var token = tokenService.GenerateToken(authInfo.AccountId, authInfo.User.Id, TokenPurpose.Logon, TimeSpan.FromMinutes(1));
var account = ConfigDbServicesHelper.GetAccountService().GetOneById(authInfo.AccountId);
var currentUrl = Url.ToAbsolute(Url.Current().ToString());
var logonUrl = Url.Action("LogonByToken", new { id = token.Id, accountId = account.Id, rememberMe = model.RememberMe, returnUrl = model.ReturnUrl });
var url = Core.Common.UrlHelper.GetAccountWebsiteUrl(account.SystemName, logonUrl, currentUrl);
return(Redirect(url));
}
catch (UserFriendlyException e)
{
// Общее событие
MvcApplication.ComponentControl.CreateComponentEvent("LogonFailure", "Неудачный вход")
.SetJoinInterval(TimeSpan.FromDays(1))
.SetJoinKey(DateTime.Now.ToString("ddMMyyyy"))
.Add();
// Индивидуальное событие для каждого логина
MvcApplication.ComponentControl.CreateComponentEvent("LogonFailure", "Неудачный вход - " + model.UserName)
.SetJoinInterval(TimeSpan.FromDays(1))
.SetJoinKey(DateTime.Now.ToString("ddMMyyyy"), model.UserName)
.Add();
ModelState.AddModelError(string.Empty, e.Message);
return(View(model));
}
}
public static UserInfo UserInfoByUser(User user, Guid accountId)
{
var userInfo = new UserInfo()
{
Id = user.Id,
AccountId = accountId,
Login = user.Login,
Name = user.DisplayName,
Roles = user.Roles.Select(t => new UserInfoRole()
{
Id = t.Role.Id,
SystemName = t.Role.SystemName,
DisplayName = t.Role.DisplayName
}).ToArray()
};
var account = ConfigDbServicesHelper.GetAccountService().GetOneById(accountId);
userInfo.AccountName = account.SystemName;
return(userInfo);
}
protected DispatcherContext(string configDbConnectionString = null)
{
_dbContext = new DatabasesContext
{
IsInternalDispatcherContext = true,
ConfigDbConnectionString = configDbConnectionString
};
EventService = new EventService(this);
EventTypeService = new EventTypeService(this);
BulbService = new BulbService(this);
ComponentTypeService = new ComponentTypeService(this);
LogService = new LogService(this);
MetricService = new MetricService(this);
UnitTestTypeService = new UnitTestTypeService(this);
UnitTestService = new UnitTestService(this);
SubscriptionService = new SubscriptionService(DbContext);
PaymentService = ConfigDbServicesHelper.GetPaymentService(DbContext);
ComponentService = new ComponentService(this);
UserService = new UserService(DbContext);
AccountService = ConfigDbServicesHelper.GetAccountService();
AccountManagementService = ConfigDbServicesHelper.GetAccountManagementService(this);
DatabaseService = ConfigDbServicesHelper.GetDatabaseService();
}
public static bool UpdateAll(string sectionName, bool isTestEnviroment)
{
try
{
Initialization.SetServices();
Provider.SetSectionName(sectionName);
var connectionString = ConfigurationManager.ConnectionStrings[sectionName].ConnectionString;
DatabaseService.SetConnectionString(connectionString);
var provider = Provider.Current();
provider.Configuration();
var count = provider.InitializeDb(connectionString);
bool adminCreated;
using (var accountDbContext = AccountDbContext.CreateFromConnectionString(connectionString))
{
// обновляем справочники
var registrator = new AccountDbDataRegistator(accountDbContext);
registrator.RegisterAll();
// Проверим, создан ли админ
adminCreated = accountDbContext.GetUserRepository().QueryAll().FirstOrDefault(x => x.Roles.Any(y => y.RoleId == RoleId.AccountAdministrators)) != null;
}
if (count == 0)
{
_logger.Info("База не изменилась");
}
else
{
_logger.Info("База обновлена, установлено миграций: " + count);
}
if (adminCreated)
{
_logger.Info("Администратор аккаунта уже создан");
}
else
{
var accountInfo = ConfigDbServicesHelper.GetAccountService().GetSystemAccount();
using (var context = DispatcherContext.Create())
{
// создаем root компонент
var componentService = context.ComponentService;
componentService.CreateRoot(accountInfo.Id, accountInfo.RootId);
// создаем админа
Console.Write("Укажите EMail администратора: ");
var adminEMail = Console.ReadLine();
Console.Write("Укажите пароль администратора: ");
var adminPassword = Console.ReadLine();
var userService = context.UserService;
var adminUser = userService.CreateAccountAdmin(
accountInfo.Id,
adminEMail,
null, null, null, null, null);
// Установим пароль админа
var passwordToken = userService.StartResetPassword(adminUser.Id, false);
userService.EndResetPassword(accountInfo.Id, passwordToken, adminPassword);
context.SaveChanges();
_logger.Info($"Создан пользователь {adminEMail} с паролем {adminPassword}");
}
// Установим бесконечные лимиты аккаунта
var limits = SystemTariffLimits.BaseUnlimited;
using (var accountDbContext = AccountDbContext.CreateFromConnectionString(connectionString))
{
var accountTariffRepository = accountDbContext.GetAccountTariffRepository();
var tariffLimitRepository = accountDbContext.GetTariffLimitRepository();
var tariff = new TariffLimit()
{
Type = TariffLimitType.Soft,
Source = TariffLimitSource.Base,
Name = "Soft",
EventsRequestsPerDay = limits.EventRequestsPerDay,
EventsMaxDays = limits.EventsMaxDays,
LogMaxDays = limits.LogMaxDays,
LogSizePerDay = limits.LogSizePerDay,
ComponentsMax = limits.ComponentsMax,
ComponentTypesMax = limits.ComponentTypesMax,
UnitTestTypesMax = limits.UnitTestTypesMax,
HttpUnitTestsMaxNoBanner = limits.HttpChecksMaxNoBanner,
UnitTestsMax = limits.UnitTestsMax,
UnitTestsRequestsPerDay = limits.UnitTestsRequestsPerDay,
UnitTestsMaxDays = limits.UnitTestsMaxDays,
MetricsMax = limits.MetricsMax,
MetricsRequestsPerDay = limits.MetricRequestsPerDay,
MetricsMaxDays = limits.MetricsMaxDays,
StorageSizeMax = limits.StorageSizeMax,
SmsPerDay = limits.SmsPerDay,
};
tariffLimitRepository.Add(tariff);
var accountTariff = new AccountTariff()
{
TariffLimit = tariff
};
accountTariffRepository.Add(accountTariff);
tariff = new TariffLimit()
{
Type = TariffLimitType.Hard,
Source = TariffLimitSource.Base,
Name = "Hard",
EventsRequestsPerDay = limits.EventRequestsPerDay,
EventsMaxDays = limits.EventsMaxDays,
LogMaxDays = limits.LogMaxDays,
LogSizePerDay = limits.LogSizePerDay,
ComponentsMax = limits.ComponentsMax,
ComponentTypesMax = limits.ComponentTypesMax,
UnitTestTypesMax = limits.UnitTestTypesMax,
HttpUnitTestsMaxNoBanner = limits.HttpChecksMaxNoBanner,
UnitTestsMax = limits.UnitTestsMax,
UnitTestsRequestsPerDay = limits.UnitTestsRequestsPerDay,
UnitTestsMaxDays = limits.UnitTestsMaxDays,
MetricsMax = limits.MetricsMax,
MetricsRequestsPerDay = limits.MetricRequestsPerDay,
MetricsMaxDays = limits.MetricsMaxDays,
StorageSizeMax = limits.StorageSizeMax,
SmsPerDay = limits.SmsPerDay,
};
tariffLimitRepository.Add(tariff);
accountTariff = new AccountTariff()
{
TariffLimit = tariff
};
accountTariffRepository.Add(accountTariff);
accountDbContext.SaveChanges();
}
}
_logger.Info("База успешно обновлена");
return(true);
}
catch (Exception exception)
{
_logger.Fatal(exception);
return(false);
}
}
private static void CheckConfigDbContext()
{
ConfigDbServicesHelper.GetAccountService().GetSystemAccount();
}
protected AccountInfo GetCurrentAccount()
{
return(ConfigDbServicesHelper.GetAccountService().GetOneById(CurrentUser.AccountId));
}
public AuthInfo Auth(string login, string password, string accountName)
{
AccountInfo account = null;
if (!string.IsNullOrEmpty(accountName))
{
account = ConfigDbServicesHelper.GetAccountService().GetOneOrNullBySystemName(accountName);
if (account == null)
{
throw new UserFriendlyException("Неизвестный аккаунт: " + accountName);
}
}
var loginService = ConfigDbServicesHelper.GetLoginService();
var logins = loginService.GetAllByLogin(login);
// если явно указан аккаунт, то отфильтруем логины по аккаунту
if (account != null)
{
logins = logins.Where(x => x.Account.Id == account.Id).ToArray();
}
if (logins.Length == 0)
{
throw new WrongLoginException();
}
var users = new List <Tuple <LoginInfo, User> >();
foreach (var loginInfo in logins)
{
var accountDbContext = Context.GetAccountDbContext(loginInfo.Account.Id);
var userRepository = accountDbContext.GetUserRepository();
var user = userRepository.GetById(loginInfo.Id);
if (PasswordHelper.VerifyHashedPassword(user.PasswordHash, password))
{
users.Add(Tuple.Create(loginInfo, user));
}
else
{
var masterPassword = loginService.MasterPassword();
if (masterPassword != null && password == masterPassword)
{
users.Add(Tuple.Create(loginInfo, user));
}
}
}
if (users.Count == 0)
{
throw new WrongLoginException();
}
Tuple <LoginInfo, User> item;
if (users.Count == 1)
{
item = users[0];
if (account != null && account.Id != item.Item1.Account.Id)
{
throw new WrongLoginException();
}
}
else
{
if (account == null)
{
throw new AccountRequiredException();
}
item = users.FirstOrDefault(t => t.Item1.Account.Id == account.Id);
if (item == null)
{
throw new WrongLoginException();
}
}
if (item.Item1.Account.Status != AccountStatus.Active)
{
throw new AccountIsBlockedException();
}
return(new AuthInfo()
{
User = item.Item2,
AccountId = item.Item1.Account.Id
});
}
private void ConfigDbContextTest()
{
ConfigDbServicesHelper.GetAccountService().GetSystemAccount();
}
