public void GetTopic_returns_the_messageForwarder_topic()
{
var repo = new NotNullable<IMomRepository>(Substitute.For<IMomRepository>());
var mediator = new ServiceEvents();
var topic = StringExtension.RandomString();
var forwarder = new MessageForwarder(topic, repo, mediator, new TransparentQuota());
Assert.Equal(forwarder.Topic, topic);
}
public void If_a_messageForwarder_for_a_given_topic_does_not_exist_creates_it()
{
NotNullable<IMomRepository> momRepository = new NotNullable<IMomRepository>(Substitute.For<IMomRepository>());
NotNullable<IServiceEvents> mediator = new ServiceEvents();
NotNullable<IQuotaFactory> quotaFactory = new QuotaFactory(new HostConfiguration());
var sut = new MessageForwarderFactory(momRepository, mediator, quotaFactory);
Assert.NotNull(sut.CreateForwarder(StringExtension.RandomString()));
}
public void When_a_message_is_sent_it_removes_the_message_from_the_repository()
{
var repository = new NotNullable<IIncommingMessageRepository>( Substitute.For<IIncommingMessageRepository>());
var serviceEvents = new ServiceEvents();
var sut = new MessageCleanerService(serviceEvents, repository);
var message = new NotNullOrWhiteSpaceString(StringExtension.RandomString());
serviceEvents.SentIncommingMessage(message);
repository.Value.Received(1).Delete(message);
}
public void It_wont_process_any_incomming_message_until_we_call_StartListening()
{
var serializer = new NotNullable<IStringSerializer>(new JsonSerializer());
var forwarderFactory = new MessageForwarderFactoryFake();
var serviceEvents = new ServiceEvents();
var sut = new MessageForwardingService(serializer, serviceEvents, forwarderFactory);
serviceEvents.SavedIncommingMessage(GenerateMessages(1, "ATopic").Value.ElementAt(0));
Assert.False(forwarderFactory.Forwarders.ContainsKey("ATopic"));
}
public void When_DeletedMessage_it_notifies_subscriptor()
{
List<string> messages = new List<string>(StringExtension.RandomStrings(6));
List<string> deletedMessages = new List<string>();
var sut = new ServiceEvents();
sut.DeletedIncommingMessageSequence.Subscribe(s => deletedMessages.Add(s));
messages.ForEach(m => sut.DeletedIncommingMessage(m));
Assert.Equal(messages.Count, deletedMessages.Count);
messages.ForEach(m => Assert.True(deletedMessages.Contains(m)));
}
public void If_a_messageForwarder_for_a_given_topic_already_exist_returns_that_instance()
{
NotNullable<IMomRepository> momRepository = new NotNullable<IMomRepository>(Substitute.For<IMomRepository>());
NotNullable<IServiceEvents> mediator = new ServiceEvents();
NotNullable<IQuotaFactory> quotaFactory = new QuotaFactory(new HostConfiguration());
var sut = new MessageForwarderFactory(momRepository, mediator, quotaFactory);
var topic = StringExtension.RandomString();
var forwarder = sut.CreateForwarder(topic);
Assert.Same(sut.CreateForwarder(topic), forwarder);
}
public Task SetPrivacyList(string[] addresses)
{
return(Task.Factory.StartNew(() =>
{
using (var client = new FullClientDisposable(this))
{
if (addresses.Length < previousAddresses.Length)
{
//address was removed
foreach (var address in previousAddresses)
{
if (addresses.Contains(address))
{
continue;
}
TelegramUtils.RunSynchronously(
client.Client.Methods.ContactsUnblockAsync(new ContactsUnblockArgs
{
Id = new InputUser
{
UserId = uint.Parse(address),
AccessHash = GetUserAccessHashIfForeign(address)
}
}));
break;
}
}
else //address was added
{
foreach (var address in addresses)
{
if (previousAddresses.Contains(address))
{
continue;
}
TelegramUtils.RunSynchronously(
client.Client.Methods.ContactsBlockAsync(new ContactsBlockArgs
{
Id = new InputUser
{
UserId = uint.Parse(address),
AccessHash = GetUserAccessHashIfForeign(address)
}
}));
break;
}
}
}
ServiceEvents.RaisePrivacyListUpdated();
previousAddresses = addresses;
}));
}
public void when_called_StartListening_it_will_process_every_incommingEvent()
{
var serializer = new NotNullable<IStringSerializer>(new JsonSerializer());
var forwarderFactory = new MessageForwarderFactoryFake();
var serviceEvents = new ServiceEvents();
var sut = new MessageForwardingService(serializer, serviceEvents, forwarderFactory);
sut.StartListening();
serviceEvents.SavedIncommingMessage(GenerateMessages(1, "ATopic").Value.ElementAt(0));
Assert.NotNull(forwarderFactory.Forwarders["ATopic"]);
forwarderFactory.Forwarders["ATopic"].Received(1).AddMessage(Arg.Any<string>());
}
public DelegateServiceHandle(T service, Func <T, HostControl, bool> start, Func <T, HostControl, bool> stop,
Func <T, HostControl, bool> pause, Func <T, HostControl, bool> @continue, Action <T, HostControl> shutdown,
ServiceEvents serviceEvents)
{
_service = service;
_start = start;
_stop = stop;
_pause = pause;
_continue = @continue;
_shutdown = shutdown;
_serviceEvents = serviceEvents;
}
public DelegateServiceBuilder(ServiceFactory <T> serviceFactory, Func <T, HostControl, bool> start,
Func <T, HostControl, bool> stop, Func <T, HostControl, bool> pause, Func <T, HostControl, bool> @continue,
Action <T, HostControl> shutdown, ServiceEvents serviceEvents)
{
_serviceFactory = serviceFactory;
_start = start;
_stop = stop;
_pause = pause;
_continue = @continue;
_shutdown = shutdown;
_serviceEvents = serviceEvents;
}
public ActionResult Events(ServiceEvents parameterserviceevents, HttpPostedFileBase Event_inputfile)
{
if (ModelState != null && ModelState.IsValid)
{
objUtility.Events(parameterserviceevents, Session["Id"].ToString(), Event_inputfile);
// return RedirectToAction("Agreement", "ServiceAgreement");
// return RedirectToAction("servicecategories", "Servicedetails");
return(RedirectToAction("SocialMedia", "Services"));
// < a href = "@Url.Action("SocialMedia", "Services")" >
}
return(View());
}
public void It_can_process_pending_messages()
{
var serializer = new NotNullable<IStringSerializer>(new JsonSerializer());
var forwarderFactory = new MessageForwarderFactoryFake();
var serviceEvents = new ServiceEvents();
var sut = new MessageForwardingService(serializer, serviceEvents, forwarderFactory);
var messages = GenerateMessages(8, "oneTopic");
sut.ProcessPendingMessages(messages);
Assert.NotNull(forwarderFactory.Forwarders["oneTopic"]);
forwarderFactory.Forwarders["oneTopic"].Received(messages.Value.Count()).AddMessage(Arg.Any<string>());
}
private void SaveNewEvent(ServiceEvents serviceEvents)
{
try
{
var eventId = (int)serviceEvents;
string eventName = Enum.GetName(typeof(ServiceEvents), serviceEvents);
_logger.WriteInfo(eventName);
AddNewActionsLog(eventId, eventName);
}
catch (Exception ex)
{
_logger.Log_Exception(ex);
}
}
public void When_SavedIncommingMessage_it_notifies_subscriptor()
{
List<string> messages = new List<string>();
List<string> savedMessages = new List<string>();
(4).Times(new Action(() =>
{
messages.Add(StringExtension.RandomString() );
}));
var sut = new ServiceEvents();
sut.SavedIncommingMessageSequence.Subscribe(s => savedMessages.Add(s.Value));
messages.ForEach(s=>sut.SavedIncommingMessage(s));
Assert.Equal(messages.Count, savedMessages.Count);
messages.ForEach(m => Assert.True(savedMessages.Contains(m)));
}
public DelegateServiceHandle(T service, Func<T, HostControl, bool> start, Func<T, HostControl, bool> stop,
Func<T, HostControl, bool> pause, Func<T, HostControl, bool> @continue, Action<T, HostControl> shutdown,
Action<T, HostControl, SessionChangedArguments> sessionChanged,
Action<T, HostControl, int> customCommand, ServiceEvents serviceEvents)
{
_service = service;
_start = start;
_stop = stop;
_pause = pause;
_continue = @continue;
_shutdown = shutdown;
_sessionChanged = sessionChanged;
_customCommand = customCommand;
_serviceEvents = serviceEvents;
}
public void When_a_message_is_removed_emits_serviceEvent_DeletedIncommingMessage()
{
var repository = new NotNullable<IIncommingMessageRepository>(Substitute.For<IIncommingMessageRepository>());
var serviceEvents = new ServiceEvents();
var sut = new MessageCleanerService(serviceEvents, repository);
var message = new NotNullOrWhiteSpaceString(StringExtension.RandomString());
bool eventEmitted = false;
serviceEvents.DeletedIncommingMessageSequence.Subscribe(new Action<NotNullOrWhiteSpaceString>(s =>
{
Assert.Equal(message.Value, s.Value);
eventEmitted = true;
}));
serviceEvents.SentIncommingMessage(message);
Assert.True(eventEmitted);
}
public DelegateServiceBuilder(ServiceFactory <T> serviceFactory, Func <T, HostControl, bool> start,
Func <T, HostControl, bool> stop, Func <T, HostControl, bool> pause, Func <T, HostControl, bool> @continue,
Action <T, HostControl> shutdown, Action <T, HostControl, SessionChangedArguments> sessionChanged,
Func <T, HostControl, PowerEventArguments, bool> powerEvent,
Action <T, HostControl, int> customCommand, ServiceEvents serviceEvents)
{
_serviceFactory = serviceFactory;
_start = start;
_stop = stop;
_pause = pause;
_continue = @continue;
_shutdown = shutdown;
_sessionChanged = sessionChanged;
_powerEvent = powerEvent;
_customCommand = customCommand;
_serviceEvents = serviceEvents;
}
public void When_a_message_is_sent_it_sends_a_sentMessage_to_the_mediator()
{
List<string> messages = new List<string>(StringExtension.RandomStrings(4));
List<string> receivedMessages = new List<string>();
var repo = new NotNullable<IMomRepository>(Substitute.For<IMomRepository>());
var mediator = new ServiceEvents();
mediator.SentIncommingMessageSequence.Subscribe(s=> receivedMessages.Add(s));
var topic = StringExtension.RandomString();
var sut = new MessageForwarder(topic, repo, mediator, new TransparentQuota());
sut.StartForwarding();
messages.ForEach(m => sut.AddMessage(m));
Thread.Sleep(200);
Assert.Equal(messages.Count, receivedMessages.Count);
messages.ForEach(m => Assert.True(receivedMessages.Contains(m)));
}
public void When_receivesMessage_it_notifies_subscriptor()
{
List<BaseEvent> messages = new List<BaseEvent>();
(4).Times(new Action(()=> {
messages.Add(new BaseEvent
{
EventID = Guid.NewGuid(),
Topic = StringExtension.RandomString()
});
}));
List<BaseEvent> receivedMessages = new List<BaseEvent>();
var sut = new ServiceEvents();
sut.ReceivedMessageSequence.Subscribe(s => receivedMessages.Add(s));
messages.ForEach(s=> sut.ReceivedMessage(s));
Assert.Equal(messages.Count, receivedMessages.Count);
messages.ForEach(m => Assert.True(receivedMessages.Contains(m)));
}
public void It_routes_each_message_by_topic()
{
var serializer = new NotNullable<IStringSerializer>(new JsonSerializer());
var forwarderFactory = new MessageForwarderFactoryFake();
var serviceEvents = new ServiceEvents();
var sut = new MessageForwardingService(serializer, serviceEvents, forwarderFactory);
var messages = GenerateMessages(8);
sut.ProcessPendingMessages(messages);
var groupedTopics = messages.Value
.GroupBy(m => serializer.Value.Deserialize<BaseEvent>(m).Topic)
.Select(g => new {
Name = g.Key,
Count = g.Count()
});
Assert.NotEmpty(groupedTopics);
groupedTopics.ToList().ForEach(topicCount =>
{
Assert.NotNull(forwarderFactory.Forwarders[topicCount.Name]);
forwarderFactory.Forwarders[topicCount.Name].Received(topicCount.Count).AddMessage(Arg.Any<string>());
});
}
public void StopSendingMessages_stops_every_awakened_forwarder()
{
var serializer = new NotNullable<IStringSerializer>(new JsonSerializer());
var forwarderFactory = new MessageForwarderFactoryFake();
var serviceEvents = new ServiceEvents();
var sut = new MessageForwardingService(serializer, serviceEvents, forwarderFactory);
var messages = GenerateMessages(8);
sut.ProcessPendingMessages(messages);
sut.StopSendingMessages();
Assert.True(forwarderFactory.Forwarders.Any());
forwarderFactory.Forwarders.ToList().ForEach(item => item.Value.Received().StopForwarding());
}
public StatelessService(
StatelessServiceContext serviceContext,
IStatelessServiceHostEventSourceReplicator serviceEventSourceReplicator,
IReadOnlyList <IStatelessServiceHostDelegateReplicator> serviceDelegateReplicators,
IReadOnlyList <IStatelessServiceHostListenerReplicator> serviceListenerReplicators)
: base(serviceContext)
{
this.serviceEvents = new ServiceEvents(
new ServiceEventBridgeCodePackage(serviceContext.CodePackageActivationContext));
this.serviceEventSource = serviceEventSourceReplicator.ReplicateFor(this);
if (this.serviceEventSource == null)
{
throw new ReplicatorProducesNullInstanceException <StatelessServiceEventSource>();
}
if (serviceDelegateReplicators != null)
{
this.serviceDelegates = serviceDelegateReplicators
.SelectMany(
replicator =>
{
var @delegate = replicator.ReplicateFor(this);
if (@delegate == null)
{
throw new ReplicatorProducesNullInstanceException <StatelessServiceDelegate>();
}
return(@delegate.Event.GetBitFlags().Select(v => (v, @delegate)));
})
.ToLookup(kv => kv.v, kv => kv.@delegate);
}
if (serviceListenerReplicators != null)
{
this.serviceListeners = serviceListenerReplicators
.Select(
replicator =>
{
var listener = replicator.ReplicateFor(this);
if (listener == null)
{
throw new ReplicatorProducesNullInstanceException <ServiceInstanceListener>();
}
return(listener);
})
.ToList();
}
this.serviceEvents.OnStartup += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContext(StatelessServiceLifecycleEvent.OnStartup),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.OnRun += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContext(StatelessServiceLifecycleEvent.OnRun),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.OnShutdown += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnShutdown(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnCodePackageAdded += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnCodePackageAdded(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnCodePackageModified += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnCodePackageModified(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnCodePackageRemoved += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnCodePackageRemoved(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnConfigPackageAdded += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnConfigPackageAdded(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnConfigPackageModified += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnConfigPackageModified(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnConfigPackageRemoved += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnConfigPackageRemoved(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnDataPackageAdded += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnDataPackageAdded(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnDataPackageModified += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnDataPackageModified(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
this.serviceEvents.CodePackage.OnDataPackageRemoved += async(
sender,
args) =>
{
try
{
await this.InvokeDelegates(
new StatelessServiceDelegateInvocationContextOnDataPackageRemoved(args.Payload),
args.CancellationToken);
args.Complete();
}
catch (Exception e)
{
args.Fail(e);
}
};
}
public void Events(ServiceEvents paramServiceEvents, string Id, HttpPostedFileBase Events_inputfile)
{
Guid UserId = ValidateUser();
if (UserId != null)
{
byte[] bytes;
string strLocation = "";
Entity enMSR = new Entity("campaign");
enMSR.Id = new Guid(Id);
OptionSetValueCollection locations = new OptionSetValueCollection();
if (paramServiceEvents.IMCAuditorium)
{
locations.Add(new OptionSetValue(100000000));
}
if (paramServiceEvents.IMCMainlobby)
{
locations.Add(new OptionSetValue(100000001));
}
enMSR["imc_locations"] = locations;
enMSR["imc_duration"] = Convert.ToInt32(paramServiceEvents.duration);
enMSR["imc_expectednumberofparticipants"] = Convert.ToInt32(paramServiceEvents.Expectedparticipant);
OptionSetValueCollection eventselements = new OptionSetValueCollection();
if (paramServiceEvents.AudiovisualSystem)
{
eventselements.Add(new OptionSetValue(1));
}
if (paramServiceEvents.Stage)
{
eventselements.Add(new OptionSetValue(2));
}
if (paramServiceEvents.PopupBanners)
{
eventselements.Add(new OptionSetValue(3));
}
if (paramServiceEvents.Flowers)
{
eventselements.Add(new OptionSetValue(4));
}
if (paramServiceEvents.Water)
{
eventselements.Add(new OptionSetValue(5));
}
if (paramServiceEvents.Printed)
{
eventselements.Add(new OptionSetValue(6));
}
if (paramServiceEvents.Lighting)
{
eventselements.Add(new OptionSetValue(7));
}
if (paramServiceEvents.Giveaways)
{
eventselements.Add(new OptionSetValue(8));
}
if (paramServiceEvents.VIPgifts)
{
eventselements.Add(new OptionSetValue(9));
}
if (paramServiceEvents.VIPgifts)
{
eventselements.Add(new OptionSetValue(10));
}
if (paramServiceEvents.VIPLunch)
{
eventselements.Add(new OptionSetValue(11));
}
if (paramServiceEvents.PhotoBooth)
{
eventselements.Add(new OptionSetValue(12));
}
if (paramServiceEvents.SMSInvitation)
{
eventselements.Add(new OptionSetValue(13));
}
if (paramServiceEvents.EmployeesInvitationEmails)
{
eventselements.Add(new OptionSetValue(14));
}
if (paramServiceEvents.Fulleventcoverage)
{
eventselements.Add(new OptionSetValue(15));
}
if (paramServiceEvents.ActivityItems)
{
eventselements.Add(new OptionSetValue(16));
}
if (paramServiceEvents.SocialMedia)
{
eventselements.Add(new OptionSetValue(17));
}
if (paramServiceEvents.SocialMediaconverge)
{
eventselements.Add(new OptionSetValue(18));
}
if (paramServiceEvents.IMCWebsiteBanner)
{
eventselements.Add(new OptionSetValue(19));
}
if (paramServiceEvents.IMCWebsiteAnnouncement)
{
eventselements.Add(new OptionSetValue(20));
}
enMSR["imc_eventelements"] = eventselements;
service.Update(enMSR);
if (Events_inputfile != null)
{
using (BinaryReader br = new BinaryReader(Events_inputfile.InputStream))
{
bytes = br.ReadBytes(Events_inputfile.ContentLength);
}
CreateNotes(strLocation, Events_inputfile.FileName, bytes, Id);
}
}
}
public SuperviseServiceBuilder(ServiceBuilderFactory serviceBuilderFactory, ServiceEvents serviceEvents)
{
_serviceBuilderFactory = serviceBuilderFactory;
_serviceEvents = serviceEvents;
}
public ControlServiceBuilder(Func <HostSettings, T> serviceFactory, ServiceEvents serviceEvents)
{
_serviceFactory = serviceFactory;
_serviceEvents = serviceEvents;
}
public SuperviseServiceBuilder(ServiceBuilderFactory serviceBuilderFactory, ServiceEvents serviceEvents)
{
_serviceBuilderFactory = serviceBuilderFactory;
_serviceEvents = serviceEvents;
}
public ControlServiceHandle(T service, ServiceEvents serviceEvents)
{
_service = service;
_serviceEvents = serviceEvents;
}
