public async Task Items_over_batch_size_should_have_ondemand_status()
{
// arrange
const long chatId = long.MaxValue;
var items = new Fixture().CreateMany <FeedItem>(3).ToList();
items.ForEach(x => x.Status = FeedItemStatus.Pending);
items.ForEach(x => x.Subscription.ApplicationUser.TelegramChatId = chatId); // same chat for all
db.FeedItems.AddRange(items);
db.SaveChanges();
// act
var service = new SenderService(settings, serviceContext, telegram);
await service.SendPendingsAsync(ct);
// assert
var sentItems = db.FeedItems.Where(x => x.Status == FeedItemStatus.Sent);
sentItems.Count().Should().Be(1);
var onDemandItems = db.FeedItems.Where(x => x.Status == FeedItemStatus.OnDemand);
onDemandItems.Count().Should().Be(2);
telegram.Received().SendOnDemandCounterAsync(chatId, 2).Wait();
}
public bool GetCookie(OJ oj)
{
try
{
oj.Statuses = OJService.SelectStatusByOJ(oj.OJID);
oj.Senders = SenderService.SelectByOJ(oj.OJID);
oj.CookieContainers = new List <CookieContainer>();
foreach (Sender sender in oj.Senders)
{
CookieContainer cookieContainer = HttpHelper.GetCooKie(oj.UrlLogin, oj.UrlLoginPart1 + sender.Username + oj.UrlLoginPart2 + sender.Password + oj.UrlLoginPart3, header);
if (cookieContainer != null)
{
oj.CookieContainers.Add(cookieContainer);
}
}
oj.QSenders = new Queue <int>();
for (int i = 0; i < oj.Senders.Count; ++i)
{
oj.QSenders.Enqueue(i);
}
return(true);
}
catch (Exception e)
{
LogService.Insert(2, e);
return(false);
}
}
public static void Run()
{
ConsoleColor.Red.WriteLine(nameof(DipBadExample));
var sender = new SenderService();
sender.Send();
}
public SenderServiceTest(ITestOutputHelper output)
{
this.plotAppService = Substitute.For<IPlotAppService>();
var logger = LoggerFactory.CreateLogger<SenderService>(output);
this.senderService = new SenderService(this.plotAppService, logger);
}
static void Main(string[] args)
{
var chunkSizeBytes = Int32.Parse(args[0]);
var sourcePath = args[1];
var adapterFactory = new AdapterFactory();
var senderService = new SenderService(adapterFactory, chunkSizeBytes, sourcePath);
senderService.Send();
}
public ChatSystemMainWindow(ContactManager contactManager, WindowMessageNotificator windowMessageNotificator, SenderService senderService)
{
_contactManager = contactManager;
_windowMessageNotificator = windowMessageNotificator;
_senderService = senderService;
InitializeComponent();
_InitializeObjects();
}
public AuthController(LocationService locationService, SignInManager <AppUser> signInManager, UserManager <AppUser> userManager, SenderService senderService, ISpecialistService specialistService, IClientService clientService)
{
_locationService = locationService;
_signInManager = signInManager;
_userManager = userManager;
_senderService = senderService;
_specialistService = specialistService;
_clientService = clientService;
}
/// <summary>
/// Appends a logging event.
/// </summary>
/// <param name="loggingEvent">The logging event to append.</param>
protected override void Append(LoggingEvent loggingEvent)
{
if (_service == null)
{
_service = new SenderService(HostName, PortNumber);
}
_service.Send(ItemHost, ItemKey, RenderLoggingEvent(loggingEvent));
}
public async Task AddUserAsyncTest()
{
var publishEndpoint = A.Fake <IPublishEndpoint>();
var logger = A.Fake <ILogger <SenderService> >();
var service = new SenderService(logger, publishEndpoint);
await service.Send(null, CancellationToken.None);
A.CallTo(() => publishEndpoint.Publish <IUserMessage>(A <UserMessage> ._, A <CancellationToken> ._)).MustHaveHappened();
}
public InfoViewModel()
{
_senderService = DependencyService.Get <ISenderService>() as SenderService;
Cities = new ObservableRangeCollection <string>();
LoadItemsCommand = new Command(async() => await ExecuteLoadItemsCommand());
LoadItemsCommand.Execute(null);
GoToBellonaCommand = new Command(() => Device.OpenUri(new Uri("http://www.bellonaelectronics.com/")));
GoToAdcesCommand = new Command(() => Device.OpenUri(new Uri("http://www.adces.ro/")));
}
public void EventCreator(string commandType, string action)
{
ISenderService logManager = new SenderService();
ServerEvent eventToLog = new ServerEvent
{
EventType = commandType,
LogBody = action,
Time = DateTime.Now
};
logManager.CreateApiLog(eventToLog);
}
static void Main(string[] args)
{
header = new HttpHeader();
MakeHttpHeader();
try
{
SqlHelper.OpenConnection();
Console.WriteLine("DataBase Connection Success");
}
catch (Exception e)
{
Console.WriteLine("DataBase Connection seemed to be Failed");
}
try
{
ojs = OJService.SelectAll();
foreach (OJ oj in ojs)
{
oj.Statuses = OJService.SelectStatusByOJ(oj.OJID);
oj.Senders = SenderService.SelectByOJ(oj.OJID);
oj.CookieContainers = new List <CookieContainer>();
foreach (Sender sender in oj.Senders)
{
CookieContainer cookieContainer = HttpHelper.GetCooKie(oj.UrlLogin, oj.UrlLoginPart1 + sender.Username + oj.UrlLoginPart2 + sender.Password, header);
if (cookieContainer != null)
{
oj.CookieContainers.Add(cookieContainer);
}
}
oj.QSenders = new Queue <int>();
for (int i = 0; i < oj.Senders.Count; ++i)
{
oj.QSenders.Enqueue(i);
}
Console.WriteLine(oj.OJName + " Succeed to Get Cookie");
}
RunID = RunIDService.Select();
Console.WriteLine("Judge Start");
StartJudge();
}
catch (Exception e)
{
LogService.Insert(2, e);
Console.WriteLine("Fail to Get Cookie");
}
Console.ReadKey();
}
public static void Run()
{
ConsoleColor.Red.WriteLine(nameof(DipGoodExample));
var messages = new List <IMessage>
{
new Sms(),
new Email()
};
var sender = new SenderService(messages);
sender.Send();
}
public void Ondemand_items_can_be_archived()
{
// arrange
var items = new Fixture().CreateMany <FeedItem>(10).ToList();
items.ForEach(x => x.Status = FeedItemStatus.Pending);
items[0].Status = FeedItemStatus.OnDemand;
db.FeedItems.AddRange(items);
db.SaveChanges();
// act
var service = new SenderService(settings, serviceContext, telegram);
service.ArchiveItems(ChatId(items[0]));
// assert
db.FeedItems.Count(x => x.Status == FeedItemStatus.Archived).Should().Be(1);
}
public async Task Pending_items_should_be_sent()
{
// arrange
var items = new Fixture().CreateMany <FeedItem>(3).ToList();
items.ForEach(x => x.Status = FeedItemStatus.Pending);
db.FeedItems.AddRange(items);
db.SaveChanges();
// act
var service = new SenderService(settings, serviceContext, telegram);
await service.SendPendingsAsync(ct);
// assert
db.FeedItems.All(x => x.Status == FeedItemStatus.Sent).Should().BeTrue();
items.ForEach(item =>
telegram.Received().SendMessageAsync(ChatId(item), item.Link).Wait());
}
static void Main()
{
var contactManager = new ContactManager();
var senderService = new SenderService();
var windowsNotificator = new WindowMessageNotificator(contactManager);
var messageListener = new MessageListener(windowsNotificator);
var listenerThread = new Thread(messageListener.Start)
{
IsBackground = true
};
listenerThread.Start();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ChatSystemMainWindow(contactManager, windowsNotificator, senderService));
}
public async Task Error_must_be_saved()
{
// arrange
var item = new Fixture().Create <FeedItem>();
item.Status = FeedItemStatus.Pending;
db.FeedItems.Add(item);
db.SaveChanges();
telegram
.SendMessageAsync(item.Subscription.ApplicationUser.TelegramChatId, item.Link)
.Throws(new Exception());
// act
var service = new SenderService(settings, serviceContext, telegram);
await service.SendPendingsAsync(ct);
// assert
db.FeedItems.Count(x => x.Status == FeedItemStatus.Error).Should().Be(1);
db.ItemErrors.Count().Should().Be(1);
}
/// <summary>
/// Executes the given function.
/// </summary>
/// <param name="function">The function.</param>
private void ExecuteFunction(Function function)
{
switch (function)
{
case Function.SendMessage:
SenderService.Send();
break;
case Function.StartListening:
ReceiverService.StartListening();
break;
case Function.StoptListening:
ReceiverService.StopListening();
break;
default:
Console.WriteLine($"Function {function} not implemented yet.");
break;
}
}
static void Main(string[] args)
{
string defaultConfigFileName = "config-default.json";
string realConfigFileName = "config.json";
string configFileName = File.Exists(realConfigFileName) ? realConfigFileName : defaultConfigFileName;
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile(configFileName);
Configuration = builder.Build();
string message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
//Init context
ServiceContext context = new ServiceContext()
{
AppleCertFileName = Configuration["ios:certfilename"],
AppleCertPassword = Configuration["ios:certpass"],
FcmUrl = Configuration["android:fcmurl"],
FcmApiKey = Configuration["android:apikey"]
};
//Get devices
List <Device> devices = new List <Device>
{
new Device(DeviceType.Android, "fJ8hGwWzwM4:APA91bFoIb2Znpbu4RG5_znXCu576mTPbf6LhO4QYBYQONujyYDW6opVOyBLzN_Esj763nbIoPUBY2FpGnGsK4VVxXm2ALeykYxJ5HoJnPAulIt1fOElrTIIbXdBoe4SmVW0adej0SWl"),
//new Device(DeviceType.Android,"reg5kj345kjhg24j5k234"),
//new Device(DeviceType.IOS,"234jhn5k2hg45h2345j43"),
//new Device(DeviceType.IOS,"j24h35kjh2345jkn2345"),
//new Device(DeviceType.Android,"j43h5k23gh452hj345h23k45hjg2k3j45"),
};
//Init service
IPushService service = new SenderService(context);
//Send
service.Send(devices, message);
Console.ReadLine();
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public EnterpriseCoreEditionModule(final org.neo4j.graphdb.factory.module.PlatformModule platformModule, final org.neo4j.causalclustering.discovery.DiscoveryServiceFactory discoveryServiceFactory)
public EnterpriseCoreEditionModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.Dependencies dependencies = platformModule.dependencies;
Dependencies dependencies = platformModule.Dependencies;
Config = platformModule.Config;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.logging.internal.LogService logging = platformModule.logging;
LogService logging = platformModule.Logging;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.fs.FileSystemAbstraction fileSystem = platformModule.fileSystem;
FileSystemAbstraction fileSystem = platformModule.FileSystem;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.layout.DatabaseLayout databaseLayout = platformModule.storeLayout.databaseLayout(config.get(org.neo4j.graphdb.factory.GraphDatabaseSettings.active_database));
DatabaseLayout databaseLayout = platformModule.StoreLayout.databaseLayout(Config.get(GraphDatabaseSettings.active_database));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.lifecycle.LifeSupport life = platformModule.life;
LifeSupport life = platformModule.Life;
CoreMonitor.register(logging.InternalLogProvider, logging.UserLogProvider, platformModule.Monitors);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.File dataDir = config.get(org.neo4j.graphdb.factory.GraphDatabaseSettings.data_directory);
File dataDir = Config.get(GraphDatabaseSettings.data_directory);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.core.state.ClusterStateDirectory clusterStateDirectory = new org.neo4j.causalclustering.core.state.ClusterStateDirectory(dataDir, databaseLayout.databaseDirectory(), false);
ClusterStateDirectory clusterStateDirectory = new ClusterStateDirectory(dataDir, databaseLayout.DatabaseDirectory(), false);
try
{
clusterStateDirectory.Initialize(fileSystem);
}
catch (ClusterStateException e)
{
throw new Exception(e);
}
dependencies.SatisfyDependency(clusterStateDirectory);
AvailabilityGuard globalGuard = GetGlobalAvailabilityGuard(platformModule.Clock, logging, platformModule.Config);
ThreadToTransactionBridgeConflict = dependencies.SatisfyDependency(new ThreadToStatementContextBridge(globalGuard));
LogProvider = logging.InternalLogProvider;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final System.Func<org.neo4j.kernel.internal.DatabaseHealth> databaseHealthSupplier = () -> platformModule.dataSourceManager.getDataSource().getDependencyResolver().resolveDependency(org.neo4j.kernel.internal.DatabaseHealth.class);
System.Func <DatabaseHealth> databaseHealthSupplier = () => platformModule.DataSourceManager.DataSource.DependencyResolver.resolveDependency(typeof(DatabaseHealth));
WatcherServiceFactoryConflict = directory => CreateFileSystemWatcherService(fileSystem, directory, logging, platformModule.JobScheduler, Config, FileWatcherFileNameFilter());
dependencies.SatisfyDependencies(WatcherServiceFactoryConflict);
LogFiles logFiles = BuildLocalDatabaseLogFiles(platformModule, fileSystem, databaseLayout);
LocalDatabase localDatabase = new LocalDatabase(databaseLayout, new StoreFiles(fileSystem, platformModule.PageCache), logFiles, platformModule.DataSourceManager, databaseHealthSupplier, globalGuard, LogProvider);
IdentityModule identityModule = new IdentityModule(platformModule, clusterStateDirectory.Get());
ClusteringModule clusteringModule = GetClusteringModule(platformModule, discoveryServiceFactory, clusterStateDirectory, identityModule, dependencies, databaseLayout);
// We need to satisfy the dependency here to keep users of it, such as BoltKernelExtension, happy.
dependencies.SatisfyDependency(SslPolicyLoader.create(Config, LogProvider));
PipelineWrapper clientPipelineWrapper = PipelineWrapperFactory().forClient(Config, dependencies, LogProvider, CausalClusteringSettings.SslPolicy);
PipelineWrapper serverPipelineWrapper = PipelineWrapperFactory().forServer(Config, dependencies, LogProvider, CausalClusteringSettings.SslPolicy);
PipelineWrapper backupServerPipelineWrapper = PipelineWrapperFactory().forServer(Config, dependencies, LogProvider, OnlineBackupSettings.ssl_policy);
NettyPipelineBuilderFactory clientPipelineBuilderFactory = new NettyPipelineBuilderFactory(clientPipelineWrapper);
NettyPipelineBuilderFactory serverPipelineBuilderFactory = new NettyPipelineBuilderFactory(serverPipelineWrapper);
NettyPipelineBuilderFactory backupServerPipelineBuilderFactory = new NettyPipelineBuilderFactory(backupServerPipelineWrapper);
_topologyService = clusteringModule.TopologyService();
long logThresholdMillis = Config.get(CausalClusteringSettings.UnknownAddressLoggingThrottle).toMillis();
SupportedProtocolCreator supportedProtocolCreator = new SupportedProtocolCreator(Config, LogProvider);
ApplicationSupportedProtocols supportedRaftProtocols = supportedProtocolCreator.CreateSupportedRaftProtocol();
ICollection <ModifierSupportedProtocols> supportedModifierProtocols = supportedProtocolCreator.CreateSupportedModifierProtocols();
ApplicationProtocolRepository applicationProtocolRepository = new ApplicationProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ApplicationProtocols.values(), supportedRaftProtocols);
ModifierProtocolRepository modifierProtocolRepository = new ModifierProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ModifierProtocols.values(), supportedModifierProtocols);
ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Client> protocolInstallerRepository = new ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Client>(asList(new RaftProtocolClientInstallerV2.Factory(clientPipelineBuilderFactory, LogProvider), new RaftProtocolClientInstallerV1.Factory(clientPipelineBuilderFactory, LogProvider)), Org.Neo4j.causalclustering.protocol.ModifierProtocolInstaller_Fields.AllClientInstallers);
Duration handshakeTimeout = Config.get(CausalClusteringSettings.HandshakeTimeout);
HandshakeClientInitializer channelInitializer = new HandshakeClientInitializer(applicationProtocolRepository, modifierProtocolRepository, protocolInstallerRepository, clientPipelineBuilderFactory, handshakeTimeout, LogProvider, platformModule.Logging.UserLogProvider);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.messaging.SenderService raftSender = new org.neo4j.causalclustering.messaging.SenderService(channelInitializer, logProvider);
SenderService raftSender = new SenderService(channelInitializer, LogProvider);
life.Add(raftSender);
this._clientInstalledProtocols = raftSender.installedProtocols;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.logging.MessageLogger<org.neo4j.causalclustering.identity.MemberId> messageLogger = createMessageLogger(config, life, identityModule.myself());
MessageLogger <MemberId> messageLogger = CreateMessageLogger(Config, life, identityModule.Myself());
RaftOutbound raftOutbound = new RaftOutbound(_topologyService, raftSender, clusteringModule.ClusterIdentity(), LogProvider, logThresholdMillis);
Outbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> loggingOutbound = new LoggingOutbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage>(raftOutbound, identityModule.Myself(), messageLogger);
_consensusModule = new ConsensusModule(identityModule.Myself(), platformModule, loggingOutbound, clusterStateDirectory.Get(), _topologyService);
dependencies.SatisfyDependency(_consensusModule.raftMachine());
_replicationModule = new ReplicationModule(_consensusModule.raftMachine(), identityModule.Myself(), platformModule, Config, loggingOutbound, clusterStateDirectory.Get(), fileSystem, LogProvider, globalGuard, localDatabase);
_coreStateMachinesModule = new CoreStateMachinesModule(identityModule.Myself(), platformModule, clusterStateDirectory.Get(), Config, _replicationModule.Replicator, _consensusModule.raftMachine(), dependencies, localDatabase);
IdContextFactoryConflict = IdContextFactoryBuilder.of(_coreStateMachinesModule.idTypeConfigurationProvider, platformModule.JobScheduler).withIdGenerationFactoryProvider(ignored => _coreStateMachinesModule.idGeneratorFactory).withFactoryWrapper(generator => new FreeIdFilteredIdGeneratorFactory(generator, _coreStateMachinesModule.freeIdCondition)).build();
// TODO: this is broken, coreStateMachinesModule.tokenHolders should be supplier, somehow...
this.TokenHoldersProviderConflict = databaseName => _coreStateMachinesModule.tokenHolders;
this.LocksSupplierConflict = _coreStateMachinesModule.locksSupplier;
this.CommitProcessFactoryConflict = _coreStateMachinesModule.commitProcessFactory;
this.AccessCapabilityConflict = new LeaderCanWrite(_consensusModule.raftMachine());
InstalledProtocolHandler serverInstalledProtocolHandler = new InstalledProtocolHandler();
this._coreServerModule = new CoreServerModule(identityModule, platformModule, _consensusModule, _coreStateMachinesModule, clusteringModule, _replicationModule, localDatabase, databaseHealthSupplier, clusterStateDirectory.Get(), clientPipelineBuilderFactory, serverPipelineBuilderFactory, backupServerPipelineBuilderFactory, serverInstalledProtocolHandler);
TypicallyConnectToRandomReadReplicaStrategy defaultStrategy = new TypicallyConnectToRandomReadReplicaStrategy(2);
defaultStrategy.Inject(_topologyService, Config, LogProvider, identityModule.Myself());
UpstreamDatabaseStrategySelector catchupStrategySelector = CreateUpstreamDatabaseStrategySelector(identityModule.Myself(), Config, LogProvider, _topologyService, defaultStrategy);
Org.Neo4j.causalclustering.catchup.CatchupAddressProvider_PrioritisingUpstreamStrategyBasedAddressProvider catchupAddressProvider = new Org.Neo4j.causalclustering.catchup.CatchupAddressProvider_PrioritisingUpstreamStrategyBasedAddressProvider(_consensusModule.raftMachine(), _topologyService, catchupStrategySelector);
RaftServerModule.CreateAndStart(platformModule, _consensusModule, identityModule, _coreServerModule, localDatabase, serverPipelineBuilderFactory, messageLogger, catchupAddressProvider, supportedRaftProtocols, supportedModifierProtocols, serverInstalledProtocolHandler);
_serverInstalledProtocols = serverInstalledProtocolHandler.installedProtocols;
EditionInvariants(platformModule, dependencies, Config, logging, life);
life.Add(_coreServerModule.membershipWaiterLifecycle);
}
private static bool HandleRequest(byte[] frame, NetworkStream networkStream)
{
try
{
IFrameHandler frameHandler = new FrameHandler(networkStream);
ICodification <HeaderStructure> header = new Header();
var logManager = new SenderService();
int logSize = 0;
HeaderStructure headerStructure = header.Decode(frame);
if (!IsHeaderStructureOk(headerStructure, frame))
{
return(true);
}
var command = headerStructure.CommandType;
switch (command)
{
case CommandType.AG:
ServerGenreManager.UploadGenre(frame);
ServerResponse(frameHandler, "Genre Uploaded");
logSize = 2;
break;
case CommandType.BG:
ServerGenreManager.DeleteGenre(frame);
ServerResponse(frameHandler, "Genre Deleted");
logSize = 1;
break;
case CommandType.MG:
ServerGenreManager.ModifyGenre(frame);
ServerResponse(frameHandler, "Genre modified");
logSize = 3;
break;
case CommandType.AP:
ServerMovieManager.Upload(frame);
ServerResponse(frameHandler, "Movie uploaded");
logSize = 3;
break;
case CommandType.BP:
ServerMovieManager.Delete(frame);
ServerResponse(frameHandler, "Movie deleted");
logSize = 1;
break;
case CommandType.MP:
ServerMovieManager.Modify(frame);
ServerResponse(frameHandler, "Movie updated");
logSize = 4;
break;
case CommandType.AS:
ServerAsociationManager.AsociateGenreToMovie(frame);
ServerResponse(frameHandler, "Movie and genre associated");
logSize = 2;
break;
case CommandType.DS:
ServerAsociationManager.DeAsociateGenreToMovie(frame);
ServerResponse(frameHandler, "Movie and genre deassociated");
logSize = 2;
break;
case CommandType.AD:
ServerDirectorManager.UploadDirector(frame);
ServerResponse(frameHandler, "Director uploaded");
logSize = 4;
break;
case CommandType.BD:
ServerDirectorManager.DeleteDirector(frame);
ServerResponse(frameHandler, "Director deleted");
logSize = 1;
break;
case CommandType.MD:
ServerDirectorManager.ModifyDirector(frame);
ServerResponse(frameHandler, "Director updated");
logSize = 5;
break;
case CommandType.SA:
string fileName = ServerMovieManager.SaveFile(frame, networkStream);
ServerResponse(frameHandler, "Sending file...@" + fileName);
ServerMovieManager.ReceiveFile(networkStream);
logSize = 2;
ServerResponse(frameHandler, "File sent");
break;
case CommandType.DM:
ServerAsociationManager.AsociateDirectorToMovie(frame);
ServerResponse(frameHandler, "Director and movie asociated");
logSize = 2;
break;
case CommandType.DD:
ServerAsociationManager.DeAsociateDirectorToMovie(frame);
ServerResponse(frameHandler, "Director and movie deasociated");
logSize = 2;
break;
case CommandType.FF:
ServerResponse(frameHandler, "Goodbye");
logSize = 1;
return(false);
default:
ServerResponse(frameHandler, "Formato de trama invalido vuelva a enviar");
break;
}
logManager.CreateLog(command.ToString().ToUpper(), frame, logSize);
return(true);
}
catch (Exception ex)
{
var logManager = new SenderService();
logManager.CreateLog("EX", frame, 1);
if (ex is FormatException || ex is ArgumentException)
{
IFrameHandler frameHandler = new FrameHandler(networkStream);
ServerResponse(frameHandler, "La trama recibida fue invalida");
}
else if (ex is IndexOutOfRangeException)
{
IFrameHandler frameHandler = new FrameHandler(networkStream);
ServerResponse(frameHandler, "El objeto solicitado en el Data esta mal construido");
}
else if (ex is BussinesLogicException || ex is AsociatedClassException)
{
IFrameHandler frameHandler = new FrameHandler(networkStream);
ServerResponse(frameHandler, ex.Message);
}
else if (ex is DataBaseException || ex is EntityBeingModifiedException)
{
IFrameHandler frameHandler = new FrameHandler(networkStream);
ServerResponse(frameHandler, ex.Message);
}
else
{
IFrameHandler frameHandler = new FrameHandler(networkStream);
ServerResponse(frameHandler, "Ha ocurrido un error inesperado vuelva a mandar su trama");
}
return(true);
}
}
/// <summary>
/// Konstruktor modelu widoku nadawców
/// </summary>
public SendersViewModel()
{
DataService = new SenderService();
Senders = new ObservableCollection <Sender>();
}
public ChatWindow(Contact contact, SenderService senderService)
{
InitializeComponent();
_contact = contact;
_senderService = senderService;
}
public void TestInitialize()
{
_context = new MockContainer();
_service = _context.Create <SenderService>();
}
public ChatWindow GetChatWindow(Contact contact, SenderService senderService)
{
return(new ChatWindow(contact, senderService));
}
public IEnumerable <ServiceMessage> Get()
{
var result = new SenderService().Receive();
return(result);
}
public ClientController(IClientService clientService, UserManager <AppUser> userManager, SenderService senderService)
{
_clientService = clientService;
_userManager = userManager;
_senderService = senderService;
}
public ServiceMessage Post(ServiceMessage dto)
{
var result = new SenderService().Send(dto);
return(result);
}
public SenderSession(SenderService sender)
{
this.sender = sender;
}