/// <summary>
/// Gets a collection of all application events from the data store. The items are sorted in descending order on the
/// <see cref="IEvent.TimestampUtc"/> property, so the most recent event is first. Returns an empty collection if no
/// events exist.
/// </summary>
/// <returns>Returns a collection of all application events from the data store.</returns>
public static IEventCollection GetAppEvents()
{
using (var repo = new EventRepository())
{
return GetEventsFromDtos(repo.GetAll().OrderByDescending(e => e.TimeStampUtc));
}
}
public ActionResult Edit(int? id)
{
Event CHevent;
if (!id.HasValue)
{
CHevent = new Event();
}
else
{
CHevent = new EventRepository().GetByID(id.Value);
if (CHevent == null)
{
return RedirectToAction("List");
}
}
EventsEditVM model = new EventsEditVM();
model.ID = CHevent.ID;
model.Name = CHevent.Name;
model.Start = CHevent.Start;
model.End = CHevent.End;
model.HallID = CHevent.HallID;
model.Halls = GetHalls();
model.Users = PopulateAssignedUsers(CHevent);
return View(model);
}
/// <summary>Creates an instance for the given language.</summary>
/// <param name="culture">The culture.</param>
/// <returns>A repository.</returns>
public IEventRepository ForCulture(CultureInfo culture)
{
Contract.Ensures(Contract.Result<IEventRepository>() != null);
IEventRepository repository = new EventRepository(this.serviceClient);
repository.Culture = culture;
return repository;
}
public async Task<ActionResult> Create(EventModel model) {
EventRepository repo = new EventRepository();
await repo.CreateCalendarEvent(model);
return RedirectToAction("Index");
}
public void CanCreateAlarmTypeAndLog()
{
IRepository<AlarmType> repoA = new AlarmTypeRepository();
AlarmType alarm = new AlarmType();
alarm.NameAlarmType = "PruebaAlarma";
alarm.Description = "Prueba descriptiva alarma";
repoA.Save(alarm);
IRepository<User> repoB = new UserRepository();
User user = new User();
user = repoB.GetById(1);
IRepository<Event> repoC = new EventRepository();
Event eventt = new Event();
eventt = repoC.GetById(2);
IRepository<Log> repoD = new LogRepository();
Log log = new Log();
log.DateTime = DateTime.Now;
log.Text = "Prueba descriptiva log";
log.Event = eventt;
log.User = user;
repoD.Save(log);
}
public async Task<ActionResult> Index() {
EventRepository repo = new EventRepository();
var events = await repo.GetCalendarEvents();
return View(events);
}
/// <summary>
/// Gets events from storage.
/// </summary>
/// <returns>Event list.</returns>
public List<Event> GetAll()
{
using (var repo = new EventRepository())
{
return repo.GetAll();
}
}
public override void SetUp()
{
base.SetUp();
DatabaseHelper.CleanEvents();
DatabaseHelper.CleanEventStreams();
var eventRepository = new EventRepository(DatabaseHelper.GetConnectionStringBuilder());
EventSerializer = new Serialization.Newtonsoft.EventSerializer();
var logger = new SerilogLogger(Log.ForContext<EventStore>());
var eventStore = new EventStore(
EventSerializer,
eventRepository,
logger,
Guid.NewGuid);
AggregateContext = new AggregateContext(
eventStore,
null, // TODO: replace with actual SnapshotStore
new AggregateHydrator(),
new DummyDispatcher());
}
public void All_Returns_Correct_Result(
EventRepository sut, IEnumerable<Event> data )
{
Database.Open().Events.Insert(data);
var result = sut.All();
result.ShouldAllBeEquivalentTo(data);
}
public int DeleteEvent(Event eventToDelete)
{
using (var repo = new EventRepository())
{
repo.Delete(eventToDelete);
return repo.Save();
}
}
public RepositoryData()
{
this._movieRepository = new MovieRepository();
this._newsRepository = new NewsRepository();
this._eventRepository = new EventRepository();
this._loungeRepository= new LoungeItemRepository();
this.movielist = new List<Movie>();
}
public override void SetUp()
{
base.SetUp();
DatabaseHelper.CleanEvents();
DatabaseHelper.CleanEventStreams();
_sut = new EventRepository(DatabaseHelper.GetConnectionStringBuilder());
}
/// <summary>
/// Saves event to storage.
/// </summary>
/// <param name="newEvent">Entity to save.</param>
/// <returns>The number of events, that does not have saved. Return 0 if everising OK.</returns>
public int AddEvent(Event newEvent)
{
ValidateEvent(newEvent);
using (var repo = new EventRepository())
{
repo.Insert(newEvent);
return repo.Save();
}
}
public CleaningEventsController()
{
assetTypes = new AssetTypeRepository(db);
assets = new AssetRepository(db);
var customers = new CustomerRepository(db);
var orders = new OrderRepository(db);
var events = new EventRepository(db);
inventory = new InventoryService(assetTypes, assets, customers, orders, events);
}
public DeliveryEventsController()
{
assetTypes = new AssetTypeRepository(db);
assets = new AssetRepository(db);
orders = new OrderRepository(db);
customers = new CustomerRepository(db);
var events = new EventRepository(db);
inventory = new InventoryService(assetTypes, assets, customers, orders, events);
shop = new ShopService(orders, customers);
}
public ActionResult Edit()
{
EventsEditVM model = new EventsEditVM();
TryUpdateModel(model);
EventRepository eventRep = new EventRepository(unitOfWork);
string selectedUsers = Request.Form["assignedUsers"];
string[] assignedUsers;
if (selectedUsers == null)
{
assignedUsers = new string[0];
}
else
{
assignedUsers = selectedUsers.Split(',');
}
Event CHevent;
if (model.ID == 0)
{
CHevent = new Event();
}
else
{
CHevent = eventRep.GetByID(model.ID);
if (CHevent == null)
{
return RedirectToAction("List");
}
}
if (!ModelState.IsValid)
{
model.Users = PopulateAssignedUsers(CHevent);
model.Halls = GetHalls();
return View(model);
}
CHevent.ID = model.ID;
CHevent.Name = model.Name;
CHevent.Start = model.Start;
CHevent.End = model.End;
CHevent.HallID = model.HallID;
UpdateEventUsers(CHevent, assignedUsers);
eventRep.Save(CHevent);
unitOfWork.Commit();
System.Threading.Tasks.Task.Run(() => EmailService.SendEmail(CHevent.Users));
return RedirectToAction("List");
}
/// <summary>
/// Permanently delete all events from the data store that are system-wide (that is, not associated with a specific gallery) and also
/// those events belonging to the specified <paramref name="galleryId" />.
/// </summary>
/// <param name="galleryId">The gallery ID.</param>
public static void ClearEventLog(int galleryId)
{
using (var repo = new EventRepository())
{
foreach (var eDto in repo.Where(e => e.FKGalleryId == galleryId || e.Gallery.IsTemplate))
{
repo.Delete(eDto);
}
repo.Save();
}
}
/// <summary>
/// Permanently remove the specified event from the data store.
/// </summary>
/// <param name="eventId">The value that uniquely identifies this application event (<see cref="IEvent.EventId"/>).</param>
public static void Delete(int eventId)
{
using (var repo = new EventRepository())
{
var aeDto = repo.Find(eventId);
if (aeDto != null)
{
repo.Delete(aeDto);
repo.Save();
}
}
}
static void Main(string[] args)
{
GenericEventHubDb context = new GenericEventHubDb();
IGenericRepository<Event> genericEventRepo = new GenericRepository<Event>(context);
IEventRepository eventRepo = new EventRepository(genericEventRepo);
IGenericRepository<Activity> genericActivityRepo = new GenericRepository<Activity>(context);
IActivityRepository activityRepo = new ActivityRepository(genericActivityRepo);
var generator = new EventGenerator(eventRepo, activityRepo);
// Generate events for next week
generator.CreateEventsForNextWeek();
}
/// <summary>
/// Initialize the database and repositories. Inject the database context to repositories.
/// </summary>
public BaseController()
{
var db = new BarContext();
BarRepository = new BarRepository(db);
BottleRepository = new BottleRepository(db);
DrinkRepository = new DrinkRepository(db);
DrinkBarRepository = new DrinkBarRepository(db);
EventRepository = new EventRepository(db);
IngredientDrinkRepository = new IngredientDrinkRepository(db);
IngredientRepository = new IngredientRepository(db);
OrderDrinkRepository = new OrderDrinkRepository(db);
OrderRepository = new OrderRepository(db);
QuantityRepository = new QuantityRepository(db);
UnitRepository = new UnitRepository(db);
UserBarRepository = new UserBarRepository(db);
UserRepository = new UserRepository(db);
UserRoleRepository = new UserRoleRepository(db);
}
public void Save()
{
IEventRepository iEventRepository = new EventRepository(this.connectionString);
EventItem eventItem = new EventItem
(
"data",
AppActs.DomainModel.Enum.EventType.ApplicationOpen,
"openScreen",
100,
"Main",
Guid.NewGuid(),
DateTime.Now,
"1.1"
);
iEventRepository.Save(this.Application.Id, this.Device.Id, eventItem);
}
public void CanGetCreatedItem()
{
IEventRepository eventRepository = new EventRepository(Context);
const string testName = "Test Event";
var newEventDto = new EventDto
{
ChurchId = 1,
Name = testName
};
var eventId = eventRepository.SaveItem(newEventDto);
var eventItem = eventRepository.GetItem(eventId);
Assert.That(eventItem.Name, Is.EqualTo(testName));
eventRepository.DeleteItem(eventId);
}
public OctopusRepository(IOctopusClient client)
{
this.Client = client;
Feeds = new FeedRepository(client);
Backups = new BackupRepository(client);
Machines = new MachineRepository(client);
MachineRoles = new MachineRoleRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
Subscriptions = new SubscriptionRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
Proxies = new ProxyRepository(client);
Tasks = new TaskRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Releases = new ReleaseRepository(client);
Deployments = new DeploymentRepository(client);
Certificates = new CertificateRepository(client);
Dashboards = new DashboardRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Artifacts = new ArtifactRepository(client);
Interruptions = new InterruptionRepository(client);
ServerStatus = new ServerStatusRepository(client);
UserRoles = new UserRolesRepository(client);
Teams = new TeamsRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Accounts = new AccountRepository(client);
Defects = new DefectsRepository(client);
Lifecycles = new LifecyclesRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
Channels = new ChannelRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Schedulers = new SchedulerRepository(client);
Tenants = new TenantRepository(client);
TagSets = new TagSetRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
}
public void Event_Dispatch_CanSendICS()
{
EventRepository eventRepo = new EventRepository(_uow);
AttendeeRepository attendeesRepo = new AttendeeRepository(_uow);
List<AttendeeDO> attendees =
new List<AttendeeDO>
{
_fixture.TestAttendee1(),
_fixture.TestAttendee2()
};
attendees.ForEach(attendeesRepo.Add);
EventDO eventDO = new EventDO
{
Description = "This is my test invitation",
Summary = @"My test invitation",
Location = @"Some place!",
StartDate = DateTime.Today.AddMinutes(5),
EndDate = DateTime.Today.AddMinutes(15),
Attendees = attendees,
Emails = new List<EmailDO>()
};
eventRepo.Add(eventDO);
Calendar.DispatchEvent(_uow, eventDO);
//Verify success
//use imap to load unread messages from the test customer account
//verify that one of the messages is a proper ICS message
//retry every 15 seconds for 1 minute
//create an Email message addressed to the customer and attach the file.
//skip for v.1: add EmailID to outbound queue
}
/// <summary>
/// Make a new instance for a Log object.
/// </summary>
/// <param name="LogMessage"></param>
/// <param name="EventID"></param>
/// <param name="UserID"></param>
/// <returns>A generic object.</returns>
Object ILoggable.GetNewLog(string LogMessage, int EventID, int UserID)
{
var NewLog = new Log();
IRepository<Event> eventRepo = new EventRepository();
IRepository<User> eventUser = new UserRepository();
try
{
NewLog.DateTime = DateTime.Now;
NewLog.Text = LogMessage;
NewLog.Event = eventRepo.GetById(EventID);
NewLog.User = eventUser.GetById(UserID);
return NewLog;
}
catch (Exception)
{
return null;
}
}
public RpgController()
{
EventRepository = new EventRepository(_context);
EventLinkItemRepository = new EventLinkItemRepository(_context);
QuestRepository = new QuestRepository(_context);
HeroRepository = new HeroRepository(_context);
SkillRepository = new SkillRepository(_context);
GuildRepository = new GuildRepository(_context);
SkillSchoolRepository = new SkillSchoolRepository(_context);
TrainingRoomRepository = new TrainingRoomRepository(_context);
CharacteristicRepository = new CharacteristicRepository(_context);
CharacteristicTypeRepository = new CharacteristicTypeRepository(_context);
StateRepository = new StateRepository(_context);
StateTypeRepository = new StateTypeRepository(_context);
//using (var scope = StaticContainer.Container.BeginLifetimeScope())
//{
// EventRepository = scope.Resolve<IEventRepository>();
// QuestRepository = scope.Resolve<IQuestRepository>();
// HeroRepository = scope.Resolve<IHeroRepository>();
// SkillRepository = scope.Resolve<ISkillRepository>();
//}
}
public string CheckIntersectionDates(Event newEvent)
{
using (var repo = new EventRepository())
{
var intersectDates = repo.GetAll(e => (e.DateBegin < newEvent.DateEnd && newEvent.DateBegin < e.DateEnd) && e.Id != newEvent.Id);
if (intersectDates.Count == 0)
{
return string.Empty;
}
var message = "Some events already exists in this period." + Environment.NewLine;
message = intersectDates.Take(5).Aggregate(message, (current, eventDate) => current +
(eventDate.Name + " " + eventDate.DateBegin.ToString(DateFormat) + " - " + eventDate.DateEnd.ToString(DateFormat) + ", "));
if (intersectDates.Count > 5)
{
message += "and others, ";
}
message = message.Remove(message.Length - 2, 2) + ".";
message += Environment.NewLine + Environment.NewLine + "Do you really want to save another event on this period?";
return message;
}
}
public QueueAdminController(BookingCandidateRepository candidateRepository, EventRepository eventRepository)
{
_candidateRepository = candidateRepository;
_eventRepository = eventRepository;
}
public RepositoryTest()
{
EventStorage = Substitute.For <IEventStorage>();
DomainEventMediator = Substitute.For <IDomainEventMediator>();
_eventRepository = new EventRepository(EventStorage, DomainEventMediator);
}
public void Dispose()
{
_eventRepository = null;
}
private async Task UpdateLastStateEntry(HostsRepository hostsrepo, HostStatesRepository staterepo, EventRepository eventrepo, CancellationToken stoppingToken)
{
var hosts = await hostsrepo.GetAllActive();
await hosts.ForEachAsync(10, async (host) =>
{
await UpdateSingleHostStateEntry(hostsrepo, staterepo, eventrepo, host);
});
}
public EventTest()
{
var repository = new EventRepository();
_eventService = new EventService(repository);
}
public OctopusRepository(IOctopusClient client, RepositoryScope repositoryScope = null)
{
Client = client;
Scope = repositoryScope ?? RepositoryScope.Unspecified();
Accounts = new AccountRepository(this);
ActionTemplates = new ActionTemplateRepository(this);
Artifacts = new ArtifactRepository(this);
Backups = new BackupRepository(this);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this);
CertificateConfiguration = new CertificateConfigurationRepository(this);
Certificates = new CertificateRepository(this);
Channels = new ChannelRepository(this);
CommunityActionTemplates = new CommunityActionTemplateRepository(this);
Configuration = new ConfigurationRepository(this);
DashboardConfigurations = new DashboardConfigurationRepository(this);
Dashboards = new DashboardRepository(this);
Defects = new DefectsRepository(this);
DeploymentProcesses = new DeploymentProcessRepository(this);
Deployments = new DeploymentRepository(this);
Environments = new EnvironmentRepository(this);
Events = new EventRepository(this);
FeaturesConfiguration = new FeaturesConfigurationRepository(this);
Feeds = new FeedRepository(this);
Interruptions = new InterruptionRepository(this);
LibraryVariableSets = new LibraryVariableSetRepository(this);
Lifecycles = new LifecyclesRepository(this);
Licenses = new LicensesRepository(this);
MachinePolicies = new MachinePolicyRepository(this);
MachineRoles = new MachineRoleRepository(this);
Machines = new MachineRepository(this);
Migrations = new MigrationRepository(this);
OctopusServerNodes = new OctopusServerNodeRepository(this);
PerformanceConfiguration = new PerformanceConfigurationRepository(this);
PackageMetadataRepository = new PackageMetadataRepository(this);
ProjectGroups = new ProjectGroupRepository(this);
Projects = new ProjectRepository(this);
ProjectTriggers = new ProjectTriggerRepository(this);
Proxies = new ProxyRepository(this);
Releases = new ReleaseRepository(this);
RetentionPolicies = new RetentionPolicyRepository(this);
Schedulers = new SchedulerRepository(this);
ServerStatus = new ServerStatusRepository(this);
Spaces = new SpaceRepository(this);
Subscriptions = new SubscriptionRepository(this);
TagSets = new TagSetRepository(this);
Tasks = new TaskRepository(this);
Teams = new TeamsRepository(this);
Tenants = new TenantRepository(this);
TenantVariables = new TenantVariablesRepository(this);
UserRoles = new UserRolesRepository(this);
Users = new UserRepository(this);
VariableSets = new VariableSetRepository(this);
Workers = new WorkerRepository(this);
WorkerPools = new WorkerPoolRepository(this);
ScopedUserRoles = new ScopedUserRoleRepository(this);
UserPermissions = new UserPermissionsRepository(this);
UserTeams = new UserTeamsRepository(this);
UserInvites = new UserInvitesRepository(this);
loadRootResource = new Lazy <RootResource>(LoadRootDocumentInner, true);
loadSpaceRootResource = new Lazy <SpaceRootResource>(LoadSpaceRootDocumentInner, true);
}
public void TestMethod1()
{
EventRepository eventRepository = new EventRepository();
eventRepository.Delete(-1);
}
public EventsController(EventRepository repository, AttendanceRepository attendanceRepository)
{
_repository = repository;
_attendanceRepository = attendanceRepository;
}
public void SaveThrowsDataAccessLayerException()
{
IEventRepository iEventRepository = new EventRepository(this.connectionString);
iEventRepository.Save(0, 0, new EventItem("07545197580", AppActs.DomainModel.Enum.EventType.Event, "searched", 30, "Main", Guid.NewGuid(), DateTime.Now, "1.1.1.1"));
}
public DashboardRepository(EventRepository eventRepository, EventParticipatedUsersRepository eventParticipatedUsersRepository)
{
_eventRepository = eventRepository;
_eventParticipatedUserRepository = eventParticipatedUsersRepository;
}
public ShowcaseRepositoryTest()
{
var config = new ContentfulConfig("test")
.Add("DELIVERY_URL", "https://fake.url")
.Add("TEST_SPACE", "SPACE")
.Add("TEST_ACCESS_KEY", "KEY")
.Add("TEST_MANAGEMENT_KEY", "KEY")
.Build();
_httpClient = new Mock <IHttpClient>();
_topicFactory = new Mock <IContentfulFactory <ContentfulReference, SubItem> >();
_crumbFactory = new Mock <IContentfulFactory <ContentfulReference, Crumb> >();
_timeprovider = new Mock <ITimeProvider>();
_eventHomepageFactory = new Mock <IContentfulFactory <ContentfulEventHomepage, EventHomepage> >();
_alertFactory = new Mock <IContentfulFactory <ContentfulAlert, Alert> >();
_mockLogger = new Mock <ILogger <ShowcaseRepository> >();
_timeprovider.Setup(o => o.Now()).Returns(new DateTime(2017, 03, 30));
var socialMediaFactory = new Mock <IContentfulFactory <ContentfulSocialMediaLink, SocialMediaLink> >();
socialMediaFactory.Setup(o => o.ToModel(It.IsAny <ContentfulSocialMediaLink>())).Returns(new SocialMediaLink("sm-link-title", "sm-link-slug", "sm-link-icon", "https://link.url", "sm-link-accountName", "sm-link-screenReader"));
_alertFactory.Setup(o => o.ToModel(It.IsAny <ContentfulAlert>())).Returns(new Alert("title", "", "", "", DateTime.MinValue, DateTime.MaxValue, string.Empty, false));
var _videoFactory = new Mock <IContentfulFactory <ContentfulVideo, Video> >();
var _profileFactory = new Mock <IContentfulFactory <ContentfulProfile, Profile> >();
var _triviaFactory = new Mock <IContentfulFactory <ContentfulTrivia, Trivia> >();
var callToActionBanner = new Mock <IContentfulFactory <ContentfulCallToActionBanner, CallToActionBanner> >();
callToActionBanner.Setup(_ => _.ToModel(It.IsAny <ContentfulCallToActionBanner>())).Returns(
new CallToActionBanner
{
Title = "title",
AltText = "altText",
ButtonText = "button text",
Image = "url",
Link = "url"
});
var spotlightBannerFactory = new Mock <IContentfulFactory <ContentfulSpotlightBanner, SpotlightBanner> >();
var contentfulFactory = new ShowcaseContentfulFactory(_topicFactory.Object, _crumbFactory.Object, _timeprovider.Object, socialMediaFactory.Object, _alertFactory.Object, _profileFactory.Object, _triviaFactory.Object, callToActionBanner.Object, _videoFactory.Object, spotlightBannerFactory.Object);
var newsListFactory = new Mock <IContentfulFactory <ContentfulNews, News> >();
var contentfulClientManager = new Mock <IContentfulClientManager>();
_contentfulClient = new Mock <IContentfulClient>();
contentfulClientManager.Setup(o => o.GetClient(config)).Returns(_contentfulClient.Object);
_eventFactory = new Mock <IContentfulFactory <ContentfulEvent, Event> >();
_cacheWrapper = new Mock <ICache>();
var _logger = new Mock <ILogger <EventRepository> >();
_configuration = new Mock <IConfiguration>();
_configuration.Setup(_ => _["redisExpiryTimes:Events"]).Returns("60");
var eventRepository = new EventRepository(config, contentfulClientManager.Object, _timeprovider.Object, _eventFactory.Object, _eventHomepageFactory.Object, _cacheWrapper.Object, _logger.Object, _configuration.Object);
_repository = new ShowcaseRepository(config, contentfulFactory, contentfulClientManager.Object, newsListFactory.Object, eventRepository, _mockLogger.Object);
}
public HeaderViewComponent(EmailSenderService emailSenderService, GalleryRepository galleryRepo, AppointmentRepository appoitmentRepo, NoticeRepository noticeRepo, SetupRepository setupRepo, PageCategoryRepository pageCategoryRepo, EventRepository eventRepo, ServicesRepository serviceRepository)
{
_galleryRepo = galleryRepo;
_noticeRepo = noticeRepo;
_setupRepo = setupRepo;
_pageCategoryRepo = pageCategoryRepo;
_eventRepo = eventRepo;
_appointmentRepo = appoitmentRepo;
_serviceRepository = serviceRepository;
_emailSenderService = emailSenderService;
}
public XtracurEventsController()
{
this.xtracurDivisionRepository = new XtracurDivisionRepository();
this.eventRepository = new EventRepository();
}
public AddNewEventViewModel()
{
eventRepository = new EventRepository();
}
public EventSourceManager(EventRepository eventRepository, MatchSynchronizer matchSynchronizer)
{
_eventRepository = eventRepository;
_matchSynchronizer = matchSynchronizer;
}
public IEnumerable <EventViewModel> GetAll()
{
EventRepository eventRepo = new EventRepository(_context);
return(eventRepo.GetAllEvents());
}
private async Task UpdateSingleHostStateEntry(HostsRepository hostsrepo, HostStatesRepository staterepo, EventRepository eventrepo, Data.Host host)
{
_logger.LogTrace($"Checking host {host.Name} ({host.Hostname})");
var state = staterepo.GetForHost(host.Id)
.Last();
var ping = new Ping();
try
{
var reply = await ping.SendPingAsync(host.Hostname, 2000);
switch (reply.Status)
{
case IPStatus.Success:
state.Delay = (int)reply.RoundtripTime;
switch (reply.RoundtripTime)
{
case long n when n < 70:
state.Status = HostState.StatusEnum.Online;
break;
case long n when n < 300:
state.Status = HostState.StatusEnum.Warning;
break;
case long n when n < 2000:
state.Status = HostState.StatusEnum.Critical;
break;
default:
state.Status = HostState.StatusEnum.Error;
break;
}
await eventrepo.Enqueue(new HostOnlineEvent { HostId = host.Id });
break;
case IPStatus.TimedOut:
state.Status = HostState.StatusEnum.Offline;
await eventrepo.Enqueue(new HostOfflineEvent { HostId = host.Id });
break;
default:
_logger.LogError($"Unknown IPStatus {reply.Status} while checking {host.Hostname}");
state.Status = HostState.StatusEnum.Error;
break;
}
}
catch (Exception)
{
_logger.LogWarning($"Error while checking {host.Name} ({host.Hostname})");
state.Status = HostState.StatusEnum.Error;
}
finally
{
_logger.LogTrace($"Check complete for host {host.Name} ({host.Hostname})");
}
}
public EventsManagementService(EventRepository eventRepository)
{
_eventRepository = eventRepository;
}
public void Setup()
{
_fileWrapper = new Mock <IFileWrapper>();
_eventRepository = new EventRepository(_fileWrapper.Object);
}
public EventController()
{
_eventRepository = new EventRepository();
_validator = new CreateEventRequestValidator();
}
public EventController()
{
this.repo = EventRepository.GetInstance();
}
private void InsertEventDetails(DataTable eventTable)
{
try
{
RoleRepository roleRepository = new RoleRepository();
Role role = roleRepository.FindRoleId(ConstantValues.POC);
foreach (DataRow row in eventTable.Rows)
{
string eventID = row["Event ID"].ToString();
EventRepository eventRepository = new EventRepository();
Event Event = eventRepository.FindEvent(eventID);
if (Event == null)
{
Event = new Event();
Event.EventId = eventID;
if (!row.IsNull("Month"))
{
Event.Month = row["Month"].ToString();
}
if (!row.IsNull("Base Location"))
{
Event.Location = row["Base Location"].ToString();
}
if (!row.IsNull("Beneficiary Name"))
{
Event.BeneficaryName = row["Beneficiary Name"].ToString();
}
if (!row.IsNull("Venue Address"))
{
Event.Address = row["Venue Address"].ToString();
}
if (!row.IsNull("Council Name"))
{
Event.CouncilName = row["Council Name"].ToString();
}
if (!row.IsNull("Project"))
{
Event.Project = row["Project"].ToString();
}
if (!row.IsNull("Category"))
{
Event.Category = row["Category"].ToString();
}
if (!row.IsNull("Event Name"))
{
Event.EventName = row["Event Name"].ToString();
}
if (!row.IsNull("Event Description"))
{
Event.EventDescription = row["Event Description"].ToString();
}
if (!row.IsNull("Event Date (DD-MM-YY)"))
{
String[] date = row["Event Date (DD-MM-YY)"].ToString().Split(new[] { '-' });
int day = Convert.ToInt32(date[0]);
int month = Convert.ToInt32(date[1]);
int a = 20;
int year = int.Parse(a.ToString() + date[2].ToString());
DateTime eventDate = new DateTime(year, month, day);
Event.EventDate = eventDate;
}
if (!row.IsNull("Total no. of volunteers"))
{
Event.VolunteerCount = Convert.ToInt32(row["Total no. of volunteers"]);
}
if (!row.IsNull("Total Volunteer Hours"))
{
Event.VolunteerHours = Convert.ToInt32(row["Total Volunteer Hours"]);
}
if (!row.IsNull("Total Travel Hours"))
{
Event.TravelHours = Convert.ToInt32(row["Total Travel Hours"]);
}
if (!row.IsNull("Overall Volunteering Hours"))
{
Event.TotalVolunteeringHours = Convert.ToInt32(row["Overall Volunteering Hours"]);
}
if (!row.IsNull("Lives Impacted"))
{
Event.LivesImpacted = Convert.ToInt32(row["Lives Impacted"]);
}
if (!row.IsNull("Activity Type"))
{
Event.ActivityType = Convert.ToInt32(row["Activity Type"]);
}
if (!row.IsNull("Status"))
{
Event.Status = row["Status"].ToString();
}
eventRepository.AddEvent(Event);
// Add POC User
String[] pocID = null; String[] pocName = null;
if (role != null)
{
if (!row.IsNull("POC ID"))
{
pocID = row["POC ID"].ToString().Split(new[] { ';' });
}
if (!row.IsNull("POC Name"))
{
pocName = row["POC Name"].ToString().Split(new[] { ';' });
}
for (int i = 0; i < pocID.Length; i++)
{
User user = new User
{
AssociateID = pocID[i],
AssociateName = pocName[i],
RoleID = role.RoleID,
EventId = eventID
};
UserRepository userRepository = new UserRepository();
userRepository.AddUser(user);
}
}
}
}
}
catch (Exception ex)
{
ExceptionLogger logger = new ExceptionLogger()
{
ControllerName = "ExcelToDB",
ActionrName = "InsertEventDetails",
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
LogDateTime = DateTime.Now
};
ExceptionRepository exceptionRepository = new ExceptionRepository();
exceptionRepository.AddException(logger);
throw ex;
}
}
public EventService(EventRepository eventRepository, ImageRepository imageRepository)
{
this._eventRepository = eventRepository;
this._imageRepository = imageRepository;
}
public EventViewModel()
{
_eventRepository = new EventRepository(https://localhost:5001/);
}
public DayBookingsController(EventRepository eventRepository, DayBookingRepository dayBookingRepository)
{
_eventRepository = eventRepository;
_dayBookingRepository = dayBookingRepository;
}
public EventsController()
{
_eventRepository = new EventRepository();
}
//
// GET: /Event/
public EventController()
{
Repository = unitOfWork.EventRepository;
}
/// <summary>Creates an instance for the given language.</summary>
/// <param name="culture">The culture.</param>
/// <returns>A repository.</returns>
public IEventRepository ForCulture(CultureInfo culture)
{
IEventRepository repository = new EventRepository(this.serviceClient);
repository.Culture = culture;
return repository;
}
public EventServiceImpl(EventRepository eventRepository, EventMaker eventMaker, IHostingEnvironment hostingEnvironment)
{
_eventRepository = eventRepository;
_eventMaker = eventMaker;
_hostingEnvironment = hostingEnvironment;
}
public void Setup()
{
target = new EventRepository(config.WriteModel.GetInstanceProvider(), config.WriteModel.GetPersistenceEngine(), config.WriteModel.GetRawStreamEntryFactory());
}
public EventGroupService(EventGroupRepository egr, EventRepository er, GroupRepository gr)
{
_egRepo = egr;
_eventRepo = er;
_groupRepo = gr;
}
public LiveController()
{
_showRepository = new ShowRepository();
_eventRepository = new EventRepository();
}
private static async Task Main(string[] args)
{
var disposables = new List <IDisposable>();
Console.WriteLine("Program started...");
var binder = new VersionedBinder();
var serializer = new JsonNetSerializer(binder);
var bus = new ObservableMessageBus();
var repo = new EventRepository(new DefaultInstanceProvider(), new WriteModel.InMemory.PersistenceEngine(serializer), new WriteModel.InMemory.RawStreamEntryFactory());
// let bus subscribe to repository and publish its committed events
repo.SubscribeTo <IMessage <IEvent> >()
.Subscribe((e) => bus.Publish(e));
// normal event processing
bus.SubscribeTo <IMessage <IEvent> >().Subscribe((e) =>
{
Console.WriteLine("Look, an event: " + e.ToString());
});
bus.SubscribeTo <SomethingDone>()
.Subscribe((e) =>
{
Console.WriteLine("Something done: " + e.Bla);
});
bus.SubscribeTo <Renamed>()
.Subscribe((e) =>
{
Console.WriteLine("Renamed: " + e.Name);
});
// complex event processing
bus.SubscribeTo <IEvent>()
.Buffer(2, 1)
.Where(x =>
x.First() is SomethingDone &&
x.Last() is INameChangeEvent)
.Subscribe((e) =>
{
Console.WriteLine("IMessage<IEvent>: Look, a new name after something done: " + (e.First() as SomethingDone).Bla + " -> " + (e.Last() as INameChangeEvent).Name);
});
bus.SubscribeTo <IEvent>()
.Buffer(2, 1)
.Where(x =>
x.First() is SomethingDone &&
x.Last() is INameChangeEvent)
.Subscribe((e) =>
{
Console.WriteLine("IEvent: Look, a new name after something done: " + (e.First() as SomethingDone).Bla + " -> " + (e.Last() as INameChangeEvent).Name);
});
bus
.SubscribeToAndUpdate <IMessage <TestAggregateRename>, TestAggregate>((aggr, cmd) =>
{
aggr.Rename(cmd.Body.Name);
}, repo);
bus.SubscribeTo <IMessage <TestAggregateDoSomething> >()
.Select(command => Observable.FromAsync(async() =>
{
var aggregate = await repo.GetAsync <TestAggregate>(command.Body.Id);
aggregate.DoSomething(command.Body.Foo);
await repo.SaveAsync(aggregate);
}))
.Concat()
.Subscribe();
Console.WriteLine("Start executing...");
var agg = new TestAggregate("abc" + Guid.NewGuid(), "test");
agg.DoSomething("bla bla bla");
agg.Rename("foo thing bar");
agg.DoSomething("ha ha");
agg.DoSomethingSpecial("<write poem>");
agg.Rename("hu?");
agg.DoSomething("hello?");
agg.Rename("Hi!");
await repo.SaveAsync(agg);
agg = await repo.GetAsync <TestAggregate>(agg.Id);
var projection = TestState.LoadState(agg.StateModel);
var projection2 = agg.StateModel;
Console.WriteLine("Name: " + projection.Name + ", " + projection.SomethingDone);
Console.WriteLine("Name: " + projection2.Name + ", " + projection2.SomethingDone);
Console.WriteLine("Try to mess with state:");
bus.Send(new TypedMessage <TestAggregateDoSomething>(Guid.NewGuid().ToString(), new TestAggregateDoSomething {
Id = agg.Id, Foo = "Command DoSomething Bla"
}, null, null, null, DateTime.UtcNow, 0));
bus.Send(new TypedMessage <TestAggregateRename>(Guid.NewGuid().ToString(), new TestAggregateRename {
Id = agg.Id, Name = "Command Renamed Name"
}, null, null, null, DateTime.UtcNow, 0));
agg = await repo.GetAsync <TestAggregate>(agg.Id);
projection2 = agg.StateModel;
Console.WriteLine("Name: " + projection2.Name);
// Console.WriteLine("Change-count: " + AlternateState.LoadState((AlernateState)null, agg.ev).ChangeCount);
//SQLite3.Config(ConfigOption.Serialized);
Console.WriteLine("-------");
Console.WriteLine("Database Persistence");
Console.WriteLine("-------");
SQLiteConnectionWithLock connectionFactory()
{
if (writeConn != null)
{
return(writeConn);
}
//SQLite3.Config(ConfigOption.Serialized);
var databaseFile = "writeDatabase.db";
var connectionString = new SQLiteConnectionString(databaseFile, SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.FullMutex, true, null);
writeConn = new SQLiteConnectionWithLock(connectionString);
using (writeConn.Lock())
{
writeConn.CreateCommand(@"PRAGMA synchronous = NORMAL;
PRAGMA journal_mode = WAL;", Array.Empty <object>()).ExecuteScalar <int>();
}
return(writeConn);
}
SQLiteConnectionWithLock readConnectionFactory()
{
if (readConn != null)
{
return(readConn);
}
//SQLite3.Config(ConfigOption.Serialized);
var databaseFile = "readDatabase.db";
var connectionString = new SQLiteConnectionString(databaseFile, SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.FullMutex, true, null);
readConn = new SQLiteConnectionWithLock(connectionString);
using (readConn.Lock())
{
readConn.CreateCommand(@"PRAGMA synchronous = NORMAL;
PRAGMA temp_store = MEMORY;
PRAGMA page_size = 4096;
PRAGMA cache_size = 10000;
PRAGMA journal_mode = WAL;", Array.Empty <object>()).ExecuteScalar <int>();
}
return(readConn);
}
var engine = new PersistenceEngine(connectionFactory, serializer);
engine.InitializeAsync().Wait();
var observerFactory = new PollingObserverFactory(engine, TimeSpan.FromMilliseconds(500));
var observer = await observerFactory.CreateObserverAsync(0);
var subscription = observer.Subscribe((s) =>
{
//Console.WriteLine("Polling: " + s.StreamName + "@" + s.StreamRevision + " - " + s.CheckpointNumber);
});
disposables.Add(subscription);
disposables.Add(observer);
await observer.StartAsync();
var repository = new EventRepository(
new DefaultInstanceProvider(),
engine,
new RawStreamEntryFactory());
string entityId = null;
Console.WriteLine("Generate 1000 entities");
var list = new List <IEventSourcedEntity>();
for (var i = 0; i < 1000; i++)
{
Console.Write(".");
entityId = Guid.NewGuid().ToString();
var entity = new TestAggregate(entityId, "test " + DateTime.Now.ToShortTimeString());
entity.Rename("asdfasdf");
entity.DoSomething("bla" + DateTime.Now.ToShortTimeString());
list.Add(entity);
}
await repository.SaveAsync(list);
list.Clear();
var loadedEntity = await repository.GetAsync <TestAggregate>(entityId);
var stopwatch = new Stopwatch();
stopwatch.Start();
var count = await engine.LoadStreamEntriesAsync().CountAsync();
stopwatch.Stop();
Console.WriteLine($"Load {count} entries: {stopwatch.ElapsedMilliseconds}ms");
Console.ReadKey();
Console.WriteLine("Commits: " + await engine.LoadStreamEntriesAsync()
//.Result
.CountAsync());
Console.WriteLine("Rename count: " + await engine.LoadStreamEntriesAsync(payloadTypes: new[] { typeof(Renamed) })
//.Result
.CountAsync());
Console.WriteLine("Rename checkpointnumbers of renames descending: " + string.Join(", ", await engine
.LoadStreamEntriesAsync(ascending: false, payloadTypes: new[] { typeof(Renamed), typeof(SomethingDone) })
//.Result
.Select(x => "" + x.CheckpointNumber).ToArrayAsync()));
Console.WriteLine("Rename count: " + await engine.LoadStreamEntriesAsync(minCheckpointNumber: await engine.GetCurrentEventStoreCheckpointNumberAsync()
//.Result
- 5, payloadTypes: new[] { typeof(Renamed) })
//.Result
.CountAsync());
Console.WriteLine("Current CheckpointNumber: " + await engine.GetCurrentEventStoreCheckpointNumberAsync()
//.Result
);
var c = readConnectionFactory();
//c.RunInTransactionAsync((SQLiteConnection connection) =>
//{
c.RunInLock((SQLiteConnection connection) =>
{
connection.CreateTable <CheckpointInfo>(CreateFlags.AllImplicit);
});
var viewModelResetter = new StorageResetter(readConnectionFactory());
var checkpointPersister = new CheckpointPersister <CheckpointInfo>(readConnectionFactory());
//Console.ReadKey();
var readRepository = new ReadRepository(readConnectionFactory);
//return;
/*
* var live = new CatchUpProjector<TestState>(
* new TestState(),
* new NullCheckpointPersister(),
* engine,
* viewModelResetter);
*
* Stopwatch stopwatch = new Stopwatch();
* stopwatch.Start();
* live.Start();
* stopwatch.Stop();
* Console.WriteLine("live: " + stopwatch.ElapsedMilliseconds + "ms");
*
* var live2 = new CatchUpProjector<VowelCountState>(
* new VowelCountState(),
* new NullCheckpointPersister(),
* engine,
* viewModelResetter);
* live2.Start();
*
* var resetter = new StorageResetter(readConnectionFactory());
* //resetter.Reset(new[] { typeof(PersistentEntity) });
*/
var persistentState = new CatchUpProjector <PersistentState>(
new PersistentState(readRepository),
checkpointPersister,
engine,
viewModelResetter,
observerFactory);
stopwatch.Start();
await persistentState.StartAsync();
_ = Task.Run(async() =>
{
while (true)
{
Console.WriteLine(persistentState.StateModel.Count);
await Task.Delay(1000).ConfigureAwait(false);
}
});
Console.ReadKey();
stopwatch.Stop();
Console.WriteLine($"persistent: {persistentState.StateModel.Count} msgs, {stopwatch.ElapsedMilliseconds}ms -> {persistentState.StateModel.Count / (stopwatch.ElapsedMilliseconds / 1000.0)}");
/*
* Console.ReadKey();
* Console.WriteLine(live.StateModel.Name);
* Console.WriteLine(live.StateModel.SomethingDone);
* Console.WriteLine(live.StateModel.StreamName);
*
*
* Console.WriteLine("a: " + live2.StateModel.ACount);
* Console.WriteLine("e: " + live2.StateModel.ECount);
* Console.WriteLine("i: " + live2.StateModel.ICount);
* Console.WriteLine("o: " + live2.StateModel.OCount);
* Console.WriteLine("u: " + live2.StateModel.UCount);
*/
Console.ReadKey();
foreach (var disp in disposables)
{
disp.Dispose();
}
observer.Dispose();
}
