public static void SetResponseOrderingRequired(IChannelHandlerContext ctx, bool required)
{
DispatcherContext dispatcherContext = GetDispatcherContext(ctx);
dispatcherContext.responseOrderingRequirementInitialized = true;
dispatcherContext.responseOrderingRequired = required;
}
private async Task SendTApplicationExceptionAsync(
TApplicationException x,
IChannelHandlerContext ctx,
ThriftMessage request,
long responseSequenceId,
TNiftyTransport requestTransport,
TProtocol inProtocol,
TProtocol outProtocol)
{
if (ctx.Channel.Open)
{
try
{
TMessage message = inProtocol.ReadMessageBegin();
outProtocol.WriteMessageBegin(new TMessage(message.Name, TMessageType.Exception, message.SeqID));
x.Write(outProtocol);
outProtocol.WriteMessageEnd();
requestTransport.setTApplicationException(x);
outProtocol.Transport.Flush();
//unrelease on requestTransport dispose;
ThriftMessage response = request.MessageFactory.Invoke(requestTransport.OutBuffer);
await WriteResponseAsync(ctx, response, responseSequenceId, DispatcherContext.IsResponseOrderingRequired(ctx));
}
catch (TException ex)
{
OnDispatchException(ctx, ex);
}
}
}
public async Task Dispatch(DispatcherContext dispatcherContext)
{
foreach (var writer in this._writers())
{
await writer.Write(dispatcherContext.Metadata, dispatcherContext.MetadataPublishContext);
}
}
public static User CreateTestUser(Guid accountId, string password = null)
{
using (var dispatcherContext = DispatcherContext.Create())
{
var userService = dispatcherContext.UserService;
var login = "******" + Guid.NewGuid();
var user = new User()
{
Login = login,
LastName = login,
FirstName = login,
MiddleName = login,
Post = "Post"
};
if (!string.IsNullOrEmpty(password))
{
user.PasswordHash = PasswordHelper.GetPasswordHashString(password);
}
// должны быть уникальные, т.к. это используется юнит-тестах уведомлений на смс
var phone = Guid.NewGuid().ToString();
user.UserContacts.Add(new UserContact()
{
Type = UserContactType.MobilePhone,
Value = phone
});
user = userService.CreateUser(user, accountId, false);
return(user);
}
}
public BulbService(DispatcherContext dispatcherContext)
{
if (dispatcherContext == null)
{
throw new ArgumentNullException("dispatcherContext");
}
Context = dispatcherContext;
}
public LogService(DispatcherContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Context = context;
}
public async Task Dispatch(DispatcherContext dispatcherContext)
{
var writers = this._dependencyResolver.ResolveAll <IFederationMetadataWriter>();
foreach (var writer in writers)
{
await writer.Write(dispatcherContext.Metadata, dispatcherContext.MetadataPublishContext);
}
}
public AccountController(ApplicationUserManager userManager,
ISecureDataFormat<AuthenticationTicket> accessTokenFormat)
{
var context = new DispatcherContext();
db = context;
idContext = context;
UserManager = userManager;
AccessTokenFormat = accessTokenFormat;
}
public static IMetricTypeCacheReadObject CreateTestMetricType(Guid accountId)
{
var name = "Counter." + Guid.NewGuid();
using (var dispatcherContext = DispatcherContext.Create())
{
var service = dispatcherContext.MetricService;
var type = service.GetOrCreateType(accountId, name);
return(type);
}
}
public FlightServiceTests()
{
var optionsBuilder = new DbContextOptionsBuilder <DispatcherContext>();
optionsBuilder.UseSqlServer(@"data source=.\SQLEXPRESS;initial catalog=DispatcherDB;integrated security=True;MultipleActiveResultSets=True;");
dispatcherContext = new DispatcherContext(optionsBuilder.Options);
_flightRepository = new Repository <Flight>(dispatcherContext);
_flightService = new FlightService(_flightRepository);
}
public static IUnitTestTypeCacheReadObject CreateTestUnitTestType(Guid accountId)
{
using (var dispatcherContext = DispatcherContext.Create())
{
var service = dispatcherContext.UnitTestTypeService;
var unitTestType = service.GetOrCreateUnitTestType(accountId, new GetOrCreateUnitTestTypeRequestData()
{
DisplayName = "Тестовый тип проверки " + Guid.NewGuid(),
SystemName = "UnitTestType.Test " + Guid.NewGuid()
});
return(unitTestType);
}
}
/// <summary>
/// Shows the selected view.
/// </summary>
/// <param name="request">The request which indicates which view to show.</param>
private void ShowView(ShowViewRequest request)
{
Action action = () => ShowViewInternal(request);
if (DispatcherContext.IsSynchronized)
{
action();
}
else
{
DispatcherContext.Invoke(action);
}
}
public static IMetricCacheReadObject CreateTestMetric(Guid accountId, Guid componentId)
{
var type = CreateTestMetricType(accountId);
using (var dispatcherContext = DispatcherContext.Create())
{
var service = dispatcherContext.MetricService;
var metricId = service.CreateMetric(accountId, componentId, type.Id);
return(AllCaches.Metrics.Find(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = metricId
}));
}
}
public static ComponentType CreateRandomComponentType(Guid accountId)
{
var guid = Guid.NewGuid().ToString();
using (var dispatcherContext = DispatcherContext.Create())
{
var data = new GetOrCreateComponentTypeRequestData()
{
DisplayName = "display name " + guid,
SystemName = "sysName " + guid
};
var type = dispatcherContext.ComponentTypeService.GetOrCreateComponentType(accountId, data);
return(type);
}
}
private static DispatcherContext GetDispatcherContext(IChannelHandlerContext ctx)
{
AttributeKey <DispatcherContext> key = AttributeKey <DispatcherContext> .ValueOf(DispatcherContext.AttributeKey);
var attachment = ctx.GetAttribute(key);
DispatcherContext dispatcherContext = attachment.Get();
if (dispatcherContext == null)
{
// No context was added yet, add one
dispatcherContext = new DispatcherContext();
attachment.Set(dispatcherContext);
}
return(dispatcherContext);
}
private void CheckResponseOrderingRequirements(IChannelHandlerContext ctx, ThriftMessage message)
{
bool messageRequiresOrderedResponses = message.IsOrderedResponsesRequired;
if (!DispatcherContext.IsResponseOrderingRequirementInitialized(ctx))
{
// This is the first request. This message will decide whether all responses on the
// channel must be strictly ordered, or whether out-of-order is allowed.
DispatcherContext.SetResponseOrderingRequired(ctx, messageRequiresOrderedResponses);
}
else if (messageRequiresOrderedResponses != DispatcherContext.IsResponseOrderingRequired(ctx))
{
// This is not the first request. Verify that the ordering requirement on this message
// is consistent with the requirement on the channel itself.
throw new NiftyException("Every message on a single channel must specify the same requirement for response ordering");
}
}
public async Task <ViewLifetimeControl> OpenAsync(ViewServiceParams parameters)
{
//if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
//{
// try
// {
// ApplicationView.ClearPersistedState("Calls");
// }
// catch { }
//}
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherContext(newView.DispatcherQueue);
var newControl = await dispatcher.DispatchAsync(async() =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Title = parameters.Title ?? string.Empty;
if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
{
newAppView.PersistedStateId = parameters.PersistentId;
}
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
newWindow.Close();
};
newWindow.Content = parameters.Content(control);
newWindow.Activate();
var preferences = ViewModePreferences.CreateDefault(parameters.ViewMode);
preferences.CustomSize = new Size(parameters.Width, parameters.Height);
await ApplicationViewSwitcher.TryShowAsViewModeAsync(newAppView.Id, parameters.ViewMode, preferences);
//newAppView.TryResizeView(new Size(parameters.Width, parameters.Height));
return(control);
}).ConfigureAwait(false);
return(newControl);
}
public async Task CreateMetadata(MetadataGenerateRequest context)
{
var configuration = this._contextFactory(context);
this._logProvider.LogMessage(String.Format("Metadata create request recieved on {0} for federation party: {1}", DateTimeOffset.Now, configuration.FederationPartyId));
var sb = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(sb))
{
await((IMetadataGenerator)this).CreateMetadata(configuration, xmlWriter);
}
var metadata = new XmlDocument();
metadata.LoadXml(sb.ToString());
this._logProvider.LogMessage(String.Format("SP matadata:\r\n{0}", sb.ToString()));
var dispatcherContext = new DispatcherContext(metadata.DocumentElement, context.Target);
await this._metadataDispatcher.Dispatch(dispatcherContext);
}
private void WriteResponseInOrder(IChannelHandlerContext ctx,
ThriftMessage response,
long responseSequenceId)
{
// Ensure responses to requests are written in the same order the requests
// were received.
lock (_responseMap) {
long currentResponseId = Interlocked.Read(ref _lastResponseWrittenId) + 1;
if (responseSequenceId != currentResponseId)
{
// This response is NOT next in line of ordered responses, save it to
// be sent later, after responses to all earlier requests have been
// sent.
_responseMap[responseSequenceId] = response;
}
else
{
// This response was next in line, write this response now, and see if
// there are others next in line that should be sent now as well.
do
{
ctx.Channel.WriteAndFlushAsync(response).GetAwaiter().GetResult();
Interlocked.Increment(ref _lastResponseWrittenId);
++currentResponseId;
response = _responseMap.RemoveAndGet(currentResponseId);
} while (null != response);
// Now that we've written some responses, check if reads should be unblocked
if (DispatcherContext.IsChannelReadBlocked(ctx))
{
long lastRequestSequenceId = Interlocked.Read(ref _dispatcherSequenceId);
if (lastRequestSequenceId <= Interlocked.Read(ref _lastResponseWrittenId) + _queuedResponseLimit)
{
DispatcherContext.UnblockChannelReads(ctx);
}
}
}
}
}
private long BlockReadingForOrderReponse(IChannelHandlerContext ctx)
{
long requestSequenceId = Interlocked.Increment(ref _dispatcherSequenceId);
if (DispatcherContext.IsResponseOrderingRequired(ctx))
{
lock (_responseMap)
{
// Limit the number of pending responses (responses which finished out of order, and are
// waiting for previous requests to be finished so they can be written in order), by
// blocking further channel reads. Due to the way Netty frame decoders work, this is more
// of an estimate than a hard limit. Netty may continue to decode and process several
// more requests that were in the latest read, even while further reads on the channel
// have been blocked.
if (requestSequenceId > Interlocked.Read(ref _lastResponseWrittenId) + _queuedResponseLimit &&
!DispatcherContext.IsChannelReadBlocked(ctx))
{
DispatcherContext.BlockChannelReads(ctx);
}
}
}
return(requestSequenceId);
}
public AccountManagementService(DispatcherContext context)
{
Context = context;
}
public User CreateUser(User user, Guid accountId, bool sendLetter = true)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (user.Login == null)
{
throw new Exception("Не заполнено поле Login");
}
var existingLogin = ConfigDbServicesHelper.GetLoginService().GetOneOrNull(accountId, user.Login);
if (existingLogin != null)
{
throw new LoginAlreadyExistsException(user.Login);
}
user.SecurityStamp = Guid.NewGuid().ToString();
user.DisplayName = user.DisplayName ?? user.Login;
user.UserContacts.Add(new UserContact()
{
Type = UserContactType.Email,
Value = user.Login
});
foreach (var role in user.Roles)
{
role.User = user;
if (role.Id == Guid.Empty)
{
role.Id = Guid.NewGuid();
}
}
foreach (var contact in user.UserContacts)
{
contact.User = user;
if (contact.Id == Guid.Empty)
{
contact.Id = Guid.NewGuid();
contact.CreateDate = DateTime.Now;
}
}
var accountContext = Context.GetAccountDbContext(accountId);
var userRepository = accountContext.GetUserRepository();
userRepository.Add(user);
ConfigDbServicesHelper.GetLoginService().Add(user.Id, accountId, user.Login);
Context.SaveChanges();
// По умолчанию включаем отправку новостей
var userSettingService = accountContext.GetUserSettingService();
userSettingService.SendMeNews(user.Id, true);
Context.SaveChanges();
// Для нового пользователя нужно создать подписки
var subscriptionService = new SubscriptionService(Context);
subscriptionService.CreateDefaultForUser(accountId, user.Id);
Context.SaveChanges();
if (sendLetter)
{
var token = StartResetPassword(user.Id, false);
using (var dispatcherContext = DispatcherContext.Create())
{
var userService = dispatcherContext.UserService;
userService.SendNewUserLetter(accountId, user.Id, token);
}
}
return(user);
}
public async Task <ViewLifetimeControl> OpenAsync(Type page, object parameter = null, string title = null,
ViewSizePreference size = ViewSizePreference.UseHalf, int session = 0, string id = "0")
{
WriteLine($"Page: {page}, Parameter: {parameter}, Title: {title}, Size: {size}");
var currentView = ApplicationView.GetForCurrentView();
title = title ?? currentView.Title;
if (parameter != null && _windows.TryGetValue(parameter, out IDispatcherContext value))
{
var newControl = await value.DispatchAsync(async() =>
{
var control = ViewLifetimeControl.GetForCurrentView();
var newAppView = ApplicationView.GetForCurrentView();
await ApplicationViewSwitcher
.SwitchAsync(newAppView.Id, currentView.Id, ApplicationViewSwitchingOptions.Default);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
else
{
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherContext(newView.Dispatcher);
if (parameter != null)
{
_windows[parameter] = dispatcher;
}
var bounds = Window.Current.Bounds;
var newControl = await dispatcher.DispatchAsync(async() =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Title = title;
if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
{
newAppView.PersistedStateId = "Floating";
}
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
if (parameter != null)
{
_windows.TryRemove(parameter, out IDispatcherContext _);
}
newWindow.Close();
};
var nav = BootStrapper.Current.NavigationServiceFactory(BootStrapper.BackButton.Ignore, BootStrapper.ExistingContent.Exclude, session, id, false);
control.NavigationService = nav;
nav.Navigate(page, parameter);
newWindow.Content = BootStrapper.Current.CreateRootElement(nav);
newWindow.Activate();
await ApplicationViewSwitcher
.TryShowAsStandaloneAsync(newAppView.Id, ViewSizePreference.Default, currentView.Id, size);
//newAppView.TryResizeView(new Windows.Foundation.Size(360, bounds.Height));
newAppView.TryResizeView(new Windows.Foundation.Size(360, 640));
return(control);
}).ConfigureAwait(false);
return(newControl);
}
}
public async Task <ViewLifetimeControl> OpenAsync(Func <ViewLifetimeControl, UIElement> content, object parameter, double width, double height, ApplicationViewMode viewMode)
{
if (_windows.TryGetValue(parameter, out IDispatcherContext value))
{
var newControl = await value.DispatchAsync(async() =>
{
var control = ViewLifetimeControl.GetForCurrentView();
var newAppView = ApplicationView.GetForCurrentView();
var preferences = ViewModePreferences.CreateDefault(viewMode);
preferences.CustomSize = new Size(width, height);
await ApplicationViewSwitcher
.TryShowAsViewModeAsync(newAppView.Id, viewMode, preferences);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
else
{
var newView = CoreApplication.CreateNewView();
var dispatcher = new DispatcherContext(newView.Dispatcher);
_windows[parameter] = dispatcher;
var newControl = await dispatcher.DispatchAsync(async() =>
{
var newWindow = Window.Current;
newWindow.Closed += (s, args) =>
{
_windows.TryRemove(parameter, out _);
};
newWindow.CoreWindow.Closed += (s, args) =>
{
_windows.TryRemove(parameter, out _);
};
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Consolidated += (s, args) =>
{
_windows.TryRemove(parameter, out _);
newWindow.Close();
};
if (ApiInformation.IsPropertyPresent("Windows.UI.ViewManagement.ApplicationView", "PersistedStateId"))
{
newAppView.PersistedStateId = "Calls";
}
var control = ViewLifetimeControl.GetForCurrentView();
control.Released += (s, args) =>
{
_windows.TryRemove(parameter, out _);
newWindow.Close();
};
newWindow.Content = content(control);
newWindow.Activate();
var preferences = ViewModePreferences.CreateDefault(viewMode);
preferences.CustomSize = new Size(width, height);
await ApplicationViewSwitcher.TryShowAsViewModeAsync(newAppView.Id, viewMode, preferences);
return(control);
}).ConfigureAwait(false);
return(newControl);
}
}
public AccountController()
{
var context = new DispatcherContext();
db = context;
idContext =context;
}
public override void ChannelActive(IChannelHandlerContext context)
{
// Reads always start out unblocked
DispatcherContext.UnblockChannelReads(context);
base.ChannelActive(context);
}
private async Task ProcessRequestAsync(
long requestSequenceId,
IChannelHandlerContext ctx,
ThriftMessage message,
TNiftyTransport messageTransport,
TProtocol inProtocol,
TProtocol outProtocol)
{
//Task.Run(() =>
//{
try
{
AtomicBoolean responseSent = new AtomicBoolean(false);
// Use AtomicReference as a generic holder class to be able to mark it final
// and pass into inner classes. Since we only use .get() and .set(), we don't
// actually do any atomic operations.
AtomicReference <ITimeout> expireTimeout = new AtomicReference <ITimeout>(null);
try
{
try
{
long timeRemaining = 0;
long timeElapsed = (DateTime.UtcNow.Ticks - message.ProcessStartTimeTicks) / 10000;
if (_queueTimeoutMillis > 0)
{
if (timeElapsed >= _queueTimeoutMillis)
{
String error = "Task stayed on the queue for " + timeElapsed +
" milliseconds, exceeding configured queue timeout of " + _queueTimeoutMillis +
" milliseconds.";
_logger.LogWarning(error);
TApplicationException taskTimeoutException = new TApplicationException(
ExceptionType.InternalError, error);
await SendTApplicationExceptionAsync(taskTimeoutException, ctx, message, requestSequenceId, messageTransport,
inProtocol, outProtocol);
return;
}
}
else if (_taskTimeoutMillis > 0)
{
if (timeElapsed >= _taskTimeoutMillis)
{
String error = "Task stayed on the queue for " + timeElapsed +
" milliseconds, exceeding configured task timeout of " + _taskTimeoutMillis +
" milliseconds.";
_logger.LogWarning(error);
TApplicationException taskTimeoutException = new TApplicationException(
ExceptionType.InternalError, error);
await SendTApplicationExceptionAsync(taskTimeoutException, ctx, message, requestSequenceId, messageTransport,
inProtocol, outProtocol);
return;
}
else
{
timeRemaining = _taskTimeoutMillis - timeElapsed;
}
}
if (timeRemaining > 0)
{
expireTimeout.Value = _taskTimeoutTimer.NewTimeout(timeout =>
{
// The immediateFuture returned by processors isn't cancellable, cancel() and
// isCanceled() always return false. Use a flag to detect task expiration.
if (responseSent.CompareAndSet(false, true))
{
TApplicationException ex = new TApplicationException(
ExceptionType.InternalError,
"Task timed out while executing."
);
// Create a temporary transport to send the exception
var duplicateBuffer = message.Buffer.Duplicate();
duplicateBuffer.ResetReaderIndex();
using (TNiftyTransport temporaryTransport = new TNiftyTransport(
ctx.Channel,
duplicateBuffer,
message.TransportType))
{
TProtocolPair protocolPair = _duplexProtocolFactory.GetProtocolPair(
TTransportPair.FromSingleTransport(temporaryTransport));
SendTApplicationExceptionAsync(ex, ctx, message,
requestSequenceId,
temporaryTransport,
protocolPair.InputProtocol,
protocolPair.OutputProtocol).GetAwaiter().GetResult();
}
}
}, TimeSpan.FromMilliseconds(timeRemaining / 10000));
}
//SSL 部分暂时不处理
IConnectionContext connectionContext = ctx.Channel.GetConnectionContext();
IRequestContext requestContext = new NiftyRequestContext(connectionContext, inProtocol, outProtocol, messageTransport);
RequestContexts.SetCurrentContext(requestContext);
try
{
//关键部分：交给 Thrift 来处理二进制。
bool result = await _processorFactory.GetProcessor(messageTransport).ProcessAsync(inProtocol, outProtocol, requestContext);
DeleteExpirationTimer(expireTimeout.Value);
try
{
// Only write response if the client is still there and the task timeout
// hasn't expired.
if (ctx.Channel.Active && responseSent.CompareAndSet(false, true))
{
ThriftMessage response = message.MessageFactory(
messageTransport.OutBuffer);
await WriteResponseAsync(ctx, response, requestSequenceId,
DispatcherContext.IsResponseOrderingRequired(ctx));
}
}
catch (Exception t)
{
this.OnDispatchException(ctx, t);
}
}
catch (Exception ex)
{
_logger.LogError(0, ex, "write response to client fault.");
DeleteExpirationTimer(expireTimeout.Value);
OnDispatchException(ctx, ex);
}
}
finally
{
RequestContexts.ClearCurrentContext();
}
}
catch (Exception ex)
{
OnDispatchException(ctx, ex);
ex.ThrowIfNecessary();
}
}
catch (Exception ex)
{
ex.ThrowIfNecessary();
}
//});
}
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);
}
}
public void SendUnitTestAfterEnablingComponentTest()
{
// Создадим отключенный компонент и проверку до создания диспетчера
Component component;
Guid unitTestId;
var account = TestHelper.GetTestAccount();
using (var dispatcherContext = DispatcherContext.Create())
{
var testAccountContext = dispatcherContext.GetAccountDbContext(account.Id);
var componentService = dispatcherContext.ComponentService;
component = componentService.GetOrCreateComponent(account.Id, new GetOrCreateComponentRequestData()
{
DisplayName = Guid.NewGuid().ToString(),
SystemName = Guid.NewGuid().ToString(),
TypeId = SystemComponentTypes.Others.Id
});
componentService.DisableComponent(account.Id, component.Id, null, null);
var unitTestTypeService = dispatcherContext.UnitTestTypeService;
var unitTestType = unitTestTypeService.GetOrCreateUnitTestType(account.Id, new GetOrCreateUnitTestTypeRequestData()
{
SystemName = "Main",
DisplayName = "Main"
});
var unitTestService = dispatcherContext.UnitTestService;
var unitTestCache = unitTestService.GetOrCreateUnitTest(account.Id, new GetOrCreateUnitTestRequestData()
{
ComponentId = component.Id,
SystemName = Guid.NewGuid().ToString(),
DisplayName = Guid.NewGuid().ToString(),
UnitTestTypeId = unitTestType.Id
});
unitTestId = unitTestCache.Id;
unitTestService.SendUnitTestResult(account.Id, new SendUnitTestResultRequestData()
{
UnitTestId = unitTestCache.Id,
Result = UnitTestResult.Unknown,
ActualIntervalSeconds = 60
});
}
// Создадим диспетчер
var dispatcher = TestHelper.GetDispatcherClient();
// Включим компонент
var componentEnableResponse = dispatcher.SetComponentEnable(account.Id, component.Id);
componentEnableResponse.Check();
// Проверим, что компонент стал серым
var getComponentTotalStateResponse = dispatcher.GetComponentTotalState(account.Id, component.Id, true);
var componentState = getComponentTotalStateResponse.Data;
Assert.Equal(MonitoringStatus.Unknown, componentState.Status);
// Отправим проверку
var sendUnitTestResultResponse = dispatcher.SendUnitTestResult(account.Id, new SendUnitTestResultRequestData()
{
UnitTestId = unitTestId,
Result = UnitTestResult.Success,
ActualIntervalSeconds = 60,
Message = "OK"
});
sendUnitTestResultResponse.Check();
// Проверим, что она отправилась
var getUnitTestStateResponse = dispatcher.GetUnitTestState(account.Id, component.Id, unitTestId);
var unitTestState = getUnitTestStateResponse.Data;
Assert.Equal(MonitoringStatus.Success, unitTestState.Status);
// Проверим, что компонент стал зелёным
getComponentTotalStateResponse = dispatcher.GetComponentTotalState(account.Id, component.Id, true);
componentState = getComponentTotalStateResponse.Data;
Assert.Equal(MonitoringStatus.Success, componentState.Status);
}
public static IAccountManagementService GetAccountManagementService(DispatcherContext context)
{
return(DependencyInjection.GetService <IAccountManagementService>(context));
}
public Repository(DispatcherContext context)
{
Context = context;
entities = Context.Set <TEntity>();
}
