protected abstract FilterServiceSPI MakeFilterService(
RuntimeExtensionServices runtimeExt,
EventTypeRepository eventTypeRepository,
StatementLifecycleServiceImpl statementLifecycleService,
RuntimeSettingsService runtimeSettingsService,
EventTypeIdResolver eventTypeIdResolver,
FilterSharedLookupableRepository filterSharedLookupableRepository);
public StageRuntimeServices(
DispatchService dispatchService,
EventBeanService eventBeanService,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EventTypeRepository eventTypeRepositoryBus,
EventTypeResolvingBeanFactory eventTypeResolvingBeanFactory,
ExceptionHandlingService exceptionHandlingService,
NamedWindowDispatchService namedWindowDispatchService,
string runtimeURI,
RuntimeSettingsService runtimeSettingsService,
StatementLifecycleService statementLifecycleService,
TableExprEvaluatorContext tableExprEvaluatorContext,
ThreadingService threadingService,
VariableManagementService variableManagementService)
{
DispatchService = dispatchService;
EventBeanService = eventBeanService;
EventBeanTypedEventFactory = eventBeanTypedEventFactory;
EventTypeRepositoryBus = eventTypeRepositoryBus;
EventTypeResolvingBeanFactory = eventTypeResolvingBeanFactory;
ExceptionHandlingService = exceptionHandlingService;
NamedWindowDispatchService = namedWindowDispatchService;
RuntimeURI = runtimeURI;
RuntimeSettingsService = runtimeSettingsService;
StatementLifecycleService = statementLifecycleService;
TableExprEvaluatorContext = tableExprEvaluatorContext;
ThreadingService = threadingService;
VariableManagementService = variableManagementService;
}
public EventTypeResolvingBeanFactoryImpl(
EventTypeRepository eventTypeRepository,
EventTypeAvroHandler avroHandler)
{
this.eventTypeRepository = eventTypeRepository;
this.avroHandler = avroHandler;
}
public EventFormViewModel(int eventID)
{
var repository = new EventRepository();
var etRepository = new EventTypeRepository();
EventTypes = etRepository.EventTypes();
try
{
var mnfEvent = repository.Find(eventID);
ID = mnfEvent.ID;
Name = mnfEvent.Name;
EventTypeID = mnfEvent.EventTypeID;
Cost = mnfEvent.Cost;
Description = mnfEvent.Description;
EventDate = mnfEvent.EventDate.ToShortDateString();
StartTime = mnfEvent.StartTime.ToShortTimeString();
EndTime = mnfEvent.EndTime.ToShortTimeString();
Location = mnfEvent.Location;
ShowEvent = mnfEvent.ShowEvent;
EventMarkup = mnfEvent.EventMarkup;
}
catch (Exception)
{
// record not found in db, return -1 for ID
ID = -1;
}
}
public InnerCircleMemberViewModel(AppUser loggedInUser)
{
User = loggedInUser;
EventTypeRepository etRep = new EventTypeRepository();
EventTypes = new SelectList(etRep.GetAll(), "Id", "Description");
}
public EventFormViewModel()
{
var etRepository = new EventTypeRepository();
Cost = "$0.00";
EventTypes = etRepository.EventTypes();
EventDate = DateTime.Today.ToShortDateString();
}
public UnitOfWork(LarcContext context)
{
_context = context;
Events = new EventRepository(_context);
EventTypes = new EventTypeRepository(_context);
Ministries = new MinistryRepository(_context);
Podcasts = new PodcastRepository(_context);
Preachers = new PreacherRepository(_context);
}
protected override FilterServiceSPI MakeFilterService(
RuntimeExtensionServices runtimeExt,
EventTypeRepository eventTypeRepository,
StatementLifecycleServiceImpl statementLifecycleService,
RuntimeSettingsService runtimeSettingsService,
EventTypeIdResolver eventTypeIdResolver,
FilterSharedLookupableRepository filterSharedLookupableRepository)
{
return new FilterServiceLockCoarse(_container.RWLockManager(), -1);
}
public void ClearAllRepoAndContext()
{
_context.Dispose();
_articleRepository = null;
_articleSourceRepository = null;
_dubiousArticleRepository = null;
_eventRepository = null;
_eventTypeRepository = null;
_context = null;
}
public EventService(EventManagerContext context, IHttpContextAccessor httpContextAccessor)
{
_context = context;
_httpContextAccessor = httpContextAccessor;
Events = new EventRepository(_context);
EventSeries = new EventSeriesRepository(_context);
EventTypes = new EventTypeRepository(_context);
Ranks = new RankRepository(_context);
Users = new UserRepository(_context);
Registrations = new RegistrationRepository(_context);
_currentUser = Users.GetUserByLDAPName(_httpContextAccessor.HttpContext.User.Identity.Name.Split('\\')[1]);
}
public EventTypeController()
{
try
{
genericRep = new GenericRepository <EventType>();
eventTypeRepo = new EventTypeRepository();
}
catch (Exception ex)
{
throw ex;
}
}
public List <Category> GetEventTypes()
{
var eventTypes = new List <Category>();
using (var db = new ManagementToolProjectEntities())
{
var resp = new EventTypeRepository(db);
var types = resp.GetAll().ToList();
var transformer = new CategoryTransformer();
eventTypes = transformer.Transform(types);
}
return(eventTypes);
}
public List <EventListViewModel> ListEvents(string s)
{
var eventRepository = new EventRepository();
var eventTypeRepository = new EventTypeRepository();
IQueryable <MNFEvent> events = eventRepository.FindByName(s).OrderByDescending(n => n.Name);
var eventList = new List <EventListViewModel>();
foreach (MNFEvent e in events)
{
var vm = new EventListViewModel();
vm.mnfEvent = e;
vm.mnfEvent.EventType = eventTypeRepository.Find(e.EventTypeID);
eventList.Add(vm);
}
return(eventList);
}
public List <EventListViewModel> ListEvents()
{
var eventRepository = new EventRepository();
var eventTypeRepository = new EventTypeRepository();
var events = eventRepository.ListEvents();
var eventList = new List <EventListViewModel>();
foreach (MNFEvent e in events)
{
var vm = new EventListViewModel();
vm.mnfEvent = e;
vm.mnfEvent.EventType = eventTypeRepository.Find(e.EventTypeID);
eventList.Add(vm);
}
return(eventList);
}
public static EventType GetTestEventType(Guid accountId)
{
using (var accountContext = AccountDbContext.CreateFromAccountId(accountId))
{
IEventTypeRepository eventTypeRepository = new EventTypeRepository(accountContext);
var eventType = new EventType()
{
Category = Core.Api.EventCategory.ComponentEvent,
DisplayName = "Тестовый тип события " + DateTime.Now.ToString("yyyy-MM-dd HH"),
ImportanceForNew = Core.Api.EventImportance.Success,
JoinIntervalSeconds = 5,
SystemName = "EventType.Test " + DateTime.Now.ToString("yyyy-MM-dd HH")
};
eventType = eventTypeRepository.GetOrCreate(eventType);
return(eventType);
}
}
public static EventType GetBuildSuperType(
Type clazz,
BeanEventTypeStemService beanEventTypeStemService,
EventTypeRepository repo,
BeanEventTypeFactoryPrivate privateFactory,
IDictionary<string, ConfigurationCommonEventTypeBean> configs)
{
var existingSuperTypeNames = beanEventTypeStemService.PublicClassToTypeNames.Get(clazz);
if (existingSuperTypeNames != null) {
var eventType = repo.GetTypeByName(existingSuperTypeNames[0]);
if (eventType != null) {
return eventType;
}
}
BuildPublicBeanType(beanEventTypeStemService, repo, clazz.FullName, clazz, privateFactory, configs);
return repo.GetTypeByName(clazz.FullName);
}
private static ISet<EventType> GetDeepSupertypes(
ISet<Type> superTypes,
BeanEventTypeStemService beanEventTypeStemService,
EventTypeRepository repo,
BeanEventTypeFactoryPrivate privateFactory,
IDictionary<string, ConfigurationCommonEventTypeBean> configs)
{
if (superTypes == null || superTypes.IsEmpty()) {
return new EmptySet<EventType>();
}
var supers = new LinkedHashSet<EventType>();
foreach (var clazz in superTypes) {
supers.Add(GetBuildSuperType(clazz, beanEventTypeStemService, repo, privateFactory, configs));
}
return supers;
}
private static EventType[] GetSuperTypes(
Type[] superTypes,
BeanEventTypeStemService beanEventTypeStemService,
EventTypeRepository repo,
BeanEventTypeFactoryPrivate privateFactory,
IDictionary<string, ConfigurationCommonEventTypeBean> configs)
{
if (superTypes == null || superTypes.Length == 0) {
return null;
}
var types = new EventType[superTypes.Length];
for (var i = 0; i < types.Length; i++) {
types[i] = GetBuildSuperType(superTypes[i], beanEventTypeStemService, repo, privateFactory, configs);
}
return types;
}
// Constructor
public MessageDisplayViewModel(Message message, string userName)
{
Message = message;
MessageTypeRepository mtRep = new MessageTypeRepository();
if (null == Message.MessageTypeReference.EntityKey)
{
MessageTypes = new SelectList(mtRep.GetAll(), "Id", "Description");
}
else
{
MessageTypes = new SelectList(mtRep.GetAll(), "Id", "Description", Message.MessageTypeReference.EntityKey.EntityKeyValues[0].Value);
}
EventTypeRepository etRep = new EventTypeRepository();
if (null == Message.EventTypeReference.EntityKey)
{
EventTypes = new SelectList(etRep.GetAll(), "Id", "Description");
}
else
{
EventTypes = new SelectList(etRep.GetAll(), "Id", "Description", Message.EventTypeReference.EntityKey.EntityKeyValues[0].Value);
}
VideoRepository vRep = new VideoRepository();
if (null == Message.VideoReference.EntityKey)
{
MyVideos = new SelectList(vRep.FindAllVideosByUser(userName).ToList(), "Id", "Description");
}
else
{
MyVideos = new SelectList(vRep.FindAllVideosByUser(userName).ToList(), "Id", "Description", Message.VideoReference.EntityKey.EntityKeyValues[0].Value);
}
if (!string.IsNullOrEmpty(userName))
{
AppUserRepository userRepository = new AppUserRepository();
User = userRepository.GetByUserName(userName);
}
}
public void EventTypeDeleteTest()
{
var account = TestHelper.GetTestAccount();
var user = TestHelper.GetAccountAdminUser(account.Id);
DeleteConfirmationModel model;
string systemName;
using (var accountContext = AccountDbContext.CreateFromAccountId(account.Id))
{
var eventTypeRepository = new EventTypeRepository(accountContext);
var eventType = new EventType()
{
Category = EventCategory.ComponentEvent,
DisplayName = "Тестовый тип события " + DateTime.Now.Ticks,
ImportanceForNew = EventImportance.Success,
JoinIntervalSeconds = 0,
SystemName = "EventType.Test " + DateTime.Now.Ticks
};
eventType = eventTypeRepository.GetOrCreate(eventType);
systemName = eventType.SystemName;
using (var controller = new EventTypesController(account.Id, user.Id))
{
var result = (ViewResultBase)controller.Delete(eventType.Id);
model = (DeleteConfirmationModel)result.Model;
}
using (var controller = new EventTypesController(account.Id, user.Id))
{
controller.Delete(model);
}
}
using (var accountContext = AccountDbContext.CreateFromAccountId(account.Id))
{
var eventTypeRepository = new EventTypeRepository(accountContext);
var eventType = eventTypeRepository.GetById(Guid.Parse(model.Id));
Assert.NotNull(eventType);
Assert.True(eventType.IsDeleted);
eventType = eventTypeRepository.GetOneOrNullBySystemName(systemName);
Assert.Null(eventType);
}
}
public void Setup()
{
//context
var options = new DbContextOptionsBuilder <Backend.DataAccess.EFModels.earlynews_testContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
_context = new earlynews_testContext(options);
//Set data in context
Seed();
//Mapper
_mapper = MappingData();
//LogRepo
var logger = new LogRepository(_context, _mapper, _logger);
//logger
_logger = new Mock <ILogger>().Object;
//All other repo
_articleRepository = new ArticleRepository(_context, _mapper, logger, _logger);
_articleRepository.DoLog = false;
_articleSourceRepository = new ArticleSourceRepository(_context, _mapper, logger, _logger);
_articleSourceRepository.DoLog = false;
_dubiousArticleRepository = new DubiousArticleRepository(_context, _mapper, logger, _logger);
_dubiousArticleRepository.DoLog = false;
_eventRepository = new EventRepository(_context, _mapper, logger, _logger);
_eventRepository.DoLog = false;
_eventTypeRepository = new EventTypeRepository(_context, _mapper, logger, _logger);
_eventTypeRepository.DoLog = false;
_scenarioRepository = new ScenarioRepository(_context, _mapper, logger, _logger);
_scenarioRepository.DoLog = false;
}
protected abstract EventTypeSerdeRepository MakeEventTypeSerdeRepository(
EventTypeRepository preconfigureds,
PathRegistry<String, EventType> eventTypePathRegistry);
protected override EventTypeResolvingBeanFactory MakeEventTypeResolvingBeanFactory(
EventTypeRepository eventTypeRepository,
EventTypeAvroHandler eventTypeAvroHandler)
{
return new EventTypeResolvingBeanFactoryImpl(eventTypeRepository, eventTypeAvroHandler);
}
protected override EventTypeSerdeRepository MakeEventTypeSerdeRepository(
EventTypeRepository preconfigureds,
PathRegistry<String, EventType> eventTypePathRegistry)
{
return EventTypeSerdeRepositoryDefault.INSTANCE;
}
public void Setup()
{
if (!isSetup)
{
_context = new earlynews_testContext();
if (!isLocal)
{
_context.connectionString = gitlabConnection;
}
_mapper = MappingData();
_logger = new Mock <ILogger>().Object;
var logger = new LogRepository(_context, _mapper, _logger);
_articleRepository = new ArticleRepository(_context, _mapper, logger, _logger);
_articleSourceRepository = new ArticleSourceRepository(_context, _mapper, logger, _logger);
_dubiousArticleRepository = new DubiousArticleRepository(_context, _mapper, logger, _logger);
_eventRepository = new EventRepository(_context, _mapper, logger, _logger);
_eventTypeRepository = new EventTypeRepository(_context, _mapper, logger, _logger);
scenarioRepository = new ScenarioRepository(_context, _mapper, logger, _logger);
}
if (!isSetup && !isLocal)
{
if (!isLocal)
{
db = new AppDb(gitlabConnection);
}
else
{
db = new AppDb(localConnection);
}
isSetup = true;
db.Connection.Open();
Console.WriteLine("Commande 1");
Console.WriteLine("------------------------------------------------------------");
var cmd = db.Connection.CreateCommand();
DirectoryInfo dir = new DirectoryInfo(Environment.CurrentDirectory);
string path = Path.Combine(dir.Parent.Parent.Parent.FullName, "dbschema.sql");
cmd.CommandText = File.ReadAllText(path);
Console.WriteLine("Commande 1 - text");
Console.WriteLine(cmd.CommandText);
cmd.ExecuteNonQuery();
Console.WriteLine("Commande 2");
Console.WriteLine("------------------------------------------------------------");
MySqlCommand comm = db.Connection.CreateCommand();
path = Path.Combine(dir.Parent.Parent.Parent.FullName, "dummydata.sql");
comm.CommandText = File.ReadAllText(path);
Console.WriteLine("Commande 2 - text");
Console.WriteLine(comm.CommandText);
comm.ExecuteNonQuery();
db.Connection.Close();
}
}
private DataMap ConstructPropertyTypes(string eventTypeName,
DataMap propertyTypesGiven,
EventTypeRepository eventAdapterService)
{
var propertyTypes = new Dictionary <string, object>();
var eventType = eventAdapterService.NameToTypeMap.Get(eventTypeName);
if (eventType == null)
{
if (propertyTypesGiven != null)
{
throw new EPException("Failed to find event type named '" + eventTypeName + "'");
}
return(propertyTypesGiven);
}
if (eventType.UnderlyingType != typeof(DataMap))
{
_beanType = eventType.UnderlyingType;
}
if (propertyTypesGiven != null && eventType.PropertyNames.Length != propertyTypesGiven.Count)
{
// allow this scenario for beans as we may want to bring in a subset of properties
if (_beanType != null)
{
return(propertyTypesGiven);
}
throw new EPException("Event type " + eventTypeName + " has already been declared with a different number of parameters");
}
foreach (var property in eventType.PropertyNames)
{
Type type;
try {
type = eventType.GetPropertyType(property);
}
catch (PropertyAccessException e) {
// thrown if trying to access an invalid property on an EventBean
throw new EPException(e);
}
if (propertyTypesGiven != null && propertyTypesGiven.Get(property) == null)
{
throw new EPException("Event type " + eventTypeName +
"has already been declared with different parameters");
}
if (propertyTypesGiven != null && !Equals(propertyTypesGiven.Get(property), type))
{
throw new EPException("Event type " + eventTypeName +
"has already been declared with a different type for property " + property);
}
// we can't set read-only properties for bean
if (eventType.UnderlyingType != typeof(DataMap))
{
var magicType = MagicType.GetCachedType(_beanType);
var magicProperty = magicType.ResolveProperty(property, PropertyResolutionStyle.CASE_SENSITIVE);
if (magicProperty == null)
{
continue;
}
if (!magicProperty.CanWrite)
{
if (propertyTypesGiven == null)
{
continue;
}
else
{
throw new EPException("Event type " + eventTypeName + "property " + property +
" is read only");
}
}
}
propertyTypes[property] = type;
}
// flatten nested types
var flattenPropertyTypes = new Dictionary <string, object>();
foreach (var prop in propertyTypes)
{
var name = prop.Key;
var type = prop.Value;
var asType = type as Type;
if ((asType != null) &&
(asType.IsGenericStringDictionary()) &&
(eventType is MapEventType))
{
var mapEventType = (MapEventType)eventType;
var nested = (DataMap)mapEventType.Types.Get(name);
foreach (var nestedProperty in nested.Keys)
{
flattenPropertyTypes.Put(name + "." + nestedProperty, nested.Get(nestedProperty));
}
}
else if (asType != null)
{
if (asType.IsNullable())
{
asType = Nullable.GetUnderlyingType(asType);
}
if ((!asType.IsPrimitive) && (asType != typeof(string)))
{
var magicType = MagicType.GetCachedType(asType);
foreach (var magicProperty in magicType.GetAllProperties(false))
{
if (magicProperty.CanWrite)
{
flattenPropertyTypes[name + '.' + magicProperty.Name] = magicProperty.PropertyType;
}
}
}
else
{
flattenPropertyTypes[name] = type;
}
}
else
{
flattenPropertyTypes[name] = type;
}
}
return(flattenPropertyTypes);
}
public EventTypeController(EventTypeRepository eventTypeRepository, bool log = true)
{
_eventTypeRepository = eventTypeRepository;
_eventTypeRepository.DoLog = log;
_log = log;
}
private static void BuildPublicBeanType(
BeanEventTypeStemService beanEventTypeStemService,
EventTypeRepository repo,
string eventTypeName,
Type clazz,
BeanEventTypeFactoryPrivate privateFactory,
IDictionary<string, ConfigurationCommonEventTypeBean> configs)
{
// check existing type
var existingType = repo.GetTypeByName(eventTypeName);
if (existingType != null) {
if (existingType.Metadata.ApplicationType != EventTypeApplicationType.CLASS) {
throw new ConfigurationException(
"Event type named '" +
eventTypeName +
"' has already been declared with differing underlying type information: Class " +
existingType.UnderlyingType.FullName +
" versus " +
clazz.Name);
}
var beanEventType = (BeanEventType) existingType;
if (beanEventType.UnderlyingType != clazz) {
throw new ConfigurationException(
"Event type named '" +
eventTypeName +
"' has already been declared with differing underlying type information: Class " +
existingType.UnderlyingType.FullName +
" versus " +
beanEventType.UnderlyingType);
}
return;
}
var optionalConfig = configs.Get(eventTypeName);
// check-allocate bean-stem
var stem = beanEventTypeStemService.GetCreateStem(clazz, optionalConfig);
// metadata
var publicId = CRC32Util.ComputeCRC32(eventTypeName);
var metadata = new EventTypeMetadata(
eventTypeName,
null,
EventTypeTypeClass.STREAM,
EventTypeApplicationType.CLASS,
NameAccessModifier.PRECONFIGURED,
EventTypeBusModifier.NONBUS,
false,
new EventTypeIdPair(publicId, -1));
// supertypes
var superTypes = GetSuperTypes(stem.SuperTypes, beanEventTypeStemService, repo, privateFactory, configs);
var deepSuperTypes = GetDeepSupertypes(
stem.DeepSuperTypes,
beanEventTypeStemService,
repo,
privateFactory,
configs);
// bean type
var startTS = optionalConfig == null ? null : optionalConfig.StartTimestampPropertyName;
var endTS = optionalConfig == null ? null : optionalConfig.EndTimestampPropertyName;
var eventType = privateFactory.EventTypeFactory.CreateBeanType(
stem,
metadata,
privateFactory,
superTypes,
deepSuperTypes,
startTS,
endTS);
repo.AddType(eventType);
}
public EventTypeCompileTimeRegistry(EventTypeRepository eventTypeRepositoryPreconfigured)
{
this._eventTypeRepositoryPreconfigured = eventTypeRepositoryPreconfigured;
}
protected abstract EventTypeResolvingBeanFactory MakeEventTypeResolvingBeanFactory(
EventTypeRepository eventTypeRepository,
EventTypeAvroHandler eventTypeAvroHandler);
