public CsvRow(StreamingService service, string animeName, string url, MalId malAnimeId)
{
Service = service;
AnimeName = animeName;
Url = url;
MalAnimeId = malAnimeId;
}
public CsvRow(StreamingService service, string animeName, string url, MalId malAnimeId)
{
Service = service;
AnimeName = animeName;
Url = url;
MalAnimeId = malAnimeId;
}
public void IsEndOfWord_Will_Return_False_If_Character_A_Letter_Or_The_Word_Is_Empty(char ch, string word)
{
var service = new StreamingService();
var result = service.IsEndOfWord(ch, word);
Assert.False(result);
}
public void IsEndOfWord_Will_Return_True_If_Character_Is_A_Space_Or_A_Full_Stop_And_The_Word_Is_Not_Empty(char ch, string word)
{
var service = new StreamingService();
var result = service.IsEndOfWord(ch, word);
Assert.True(result);
}
public void AddCharacterToWord_Will_Not_Add_Character_To_Word_If_It_Is_A_Space_Or_Full_Stop(char ch, string word)
{
var service = new StreamingService();
var updatedWord = service.AddCharacterToWord(ch, word);
Assert.Equal(updatedWord, word);
}
public void AddCharacterToWord_Will_Add_Character_To_Word_If_It_Is_A_Letter(char ch, string word)
{
var service = new StreamingService();
var updatedWord = service.AddCharacterToWord(ch, word);
Assert.Equal(updatedWord, word + ch.ToString());
}
/// <summary>
/// Regex must have a named capture group called AnimeName and Url
/// </summary>
/// <param name="url"></param>
/// <param name="regex"></param>
public HtmlRegexAnimeStreamInfoSource(string url, Regex animeRegex, StreamingService service, HtmlRegexContext animeNameContext, HtmlRegexContext urlContext)
{
Url = url;
AnimeRegex = animeRegex;
Service = service;
AnimeNameContext = animeNameContext;
UrlContext = urlContext;
}
/// <summary>
/// Regex must have named capture groups called AnimeName and Url
/// </summary>
/// <param name="url"></param>
/// <param name="regex"></param>
public HtmlRegexAnimeStreamInfoSource(string url, Regex animeRegex, string html, StreamingService service, HtmlRegexContext animeNameContext, HtmlRegexContext urlContext)
{
Url = url;
AnimeRegex = animeRegex;
Html = html;
Service = service;
AnimeNameContext = animeNameContext;
UrlContext = urlContext;
}
/// <summary>
/// Set current streaming settings
/// </summary>
/// <param name="service">Service settings</param>
/// <param name="save">Save to disk</param>
public void SetStreamingSettings(StreamingService service, bool save)
{
var jsonSettings = JsonConvert.SerializeObject(service.Settings);
var requestFields = new JObject();
requestFields.Add("type", service.Type);
requestFields.Add("settings", jsonSettings);
requestFields.Add("save", save);
_webSocket.SendRequest("SetStreamSettings", requestFields);
}
static List <CsvRow> LoadCsv(string inputFile)
{
List <CsvRow> inputCsvRows = new List <CsvRow>();
var csvConfig = new CsvHelper.Configuration.Configuration()
{
AllowComments = false,
HasHeaderRecord = true,
IgnoreBlankLines = true,
IncludePrivateMembers = true,
TrimOptions = CsvHelper.Configuration.TrimOptions.None,
};
using (FileStream inputStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read, FileShare.Read))
using (TextReader inputReader = new StreamReader(inputStream, Encoding.UTF8))
using (CsvReader csvReader = new CsvReader(inputReader, csvConfig))
{
csvReader.Read();
csvReader.ReadHeader();
while (csvReader.Read())
{
StreamingService service = csvReader.GetField <StreamingService>("Service");
string animeName = csvReader.GetField <string>("Anime");
string url = csvReader.GetField <string>("URL");
string malIdString = csvReader.GetField <string>("MAL ID (or n/a)");
MalId malId;
// could be blank
if (string.IsNullOrWhiteSpace(malIdString))
{
malId = new MalId(malAnimeId: null, specified: false);
}
else if (malIdString.Equals("n/a", StringComparison.OrdinalIgnoreCase))
{
// n/a means the stream does not correspond to a MAL anime. Maybe it's a stream of anime reviews
// or maybe it's something incredibly obscure.
malId = new MalId(malAnimeId: null, specified: true);
}
else
{
int malIdInt = int.Parse(malIdString);
malId = new MalId(malAnimeId: malIdInt, specified: true);
}
CsvRow row = new CsvRow(service, animeName, url, malId);
inputCsvRows.Add(row);
}
}
return(inputCsvRows);
}
public void AddWordToSummary_Will_Add_New_Word_To_List_Of_Words_In_Summary_With_Frequency_1_If_It_Doesnt_Exist()
{
var service = new StreamingService();
const string text = "word";
service.AddWordToSummary(text);
var word = service.summary.Words.FirstOrDefault(w => w.Text == text);
Assert.NotNull(word);
Assert.Equal(text, word.Text);
Assert.Equal(1, word.Frequency);
}
/// <summary>
/// Set current streaming settings
/// </summary>
/// <param name="service">Service settings</param>
/// <param name="save">Save to disk</param>
public void SetStreamingSettings(StreamingService service, bool save)
{
var jsonSettings = JsonConvert.SerializeObject(service.Settings);
var requestFields = new JObject
{
{ "type", service.Type },
{ "settings", jsonSettings },
{ "save", save }
};
FireRequest("SetStreamSettings", requestFields);
}
public Streaming(StreamingService serviceInstance)
{
service = serviceInstance;
sharing = new WatchSharing();
ThreadManager.Start("StreamTimeout", TimeoutStreamsWorker);
ServiceState.Stopping += delegate()
{
foreach(var identifier in Streams.Select(x => x.Value.Identifier).ToList())
{
Log.Warn("Killing stream {0} because of service stop", identifier);
KillStream(identifier);
}
};
}
public ActionResult Index()
{
List <StreamingService> StreamingService = _db.GetAllStreamingServices();
StreamingService St = _db.GetAllStreamingServices().FirstOrDefault <StreamingService>();
_db.Entry(St).Collection(s => s.Users).Load();
if (Session["username"] != null)
{
return(RedirectToAction("StreamingServices", "Streaming", new { username = Session["username"].ToString() }));
}
return(View());
}
public static void BotReply(string message, StreamingService service)
{
switch (service)
{
case StreamingService.Twitch:
if (Program.Configuration.TwitchReply)
{
TwitchClient.SendMessage(Program.Configuration.TwitchChannelName, message);
}
break;
default:
break;
}
}
static void Main(string[] args)
{
StreamingService service = new StreamingService();
Timer timer = new Timer(TimerCallback, service.summary, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
try
{
service.Start();
}
catch (Exception ex)
{
Console.WriteLine("There was an exception processing the stream:\n" + ex.Message);
}
Console.WriteLine("The stream has completed.");
Console.ReadLine();
}
private void OnAddServiceCliked(object sender, RoutedEventArgs e)
{
using (var db = new StreamingContext())
{
db.AddStreamingService(_streamingService);
db.SaveChanges();
List <StreamingService> items = new List <StreamingService>();
foreach (StreamingService el in db.GetAllStreamingServices())
{
items.Add(el);
}
lvDataBinding.ItemsSource = items;
MessageBox.Show($"Der er oprettet en ny service med navn: {_streamingService.Name}");
_streamingService = new StreamingService();
DataContext = _streamingService;
}
}
public void AddWordToSummary_Will_Increment_Frequency_Of_Word_In_List_Of_Words_In_Summary_If_It_Does_Exist()
{
var service = new StreamingService();
const string text = "word";
service.summary.Words.Add(new Domain.Word(text, 4));
var totalWords = service.summary.Words.Count();
service.AddWordToSummary(text);
var word = service.summary.Words.FirstOrDefault(w => w.Text == text);
Assert.NotNull(word);
Assert.Equal(text, word.Text);
Assert.Equal(2, word.Frequency);
Assert.Equal(totalWords, service.summary.Words.Count());
}
// Constructors
public ChatMessage(string sender, string commandText, List <string> commandArguments, StreamingService service, bool isBroadcast = false, bool isModerator = false)
{
Sender = sender;
CommandText = commandText;
Service = service;
Arguments = commandArguments;
Role = Rank.Standard;
if (isModerator)
{
Role |= Rank.Moderator;
}
if (isBroadcast)
{
Role |= Rank.Broadcaster;
}
CommandExecution.SetCommand = this;
}
private void OnUserStatusChanged(System.Object aSource, AuthenticationEventArgs aArgs)
{
ExecuteSecure(() =>
{
ProfileService profileService = (ProfileService)aSource;
/*ConsoleWriteLine("User status changed: " + profileService.UserStatus.ToString() + " (" + aArgs.AuthenticationStatus.ToString() + ")");
* foreach (IApplicationState control in ApplicationControls)
* {
* control.OnUserStatusEvent(profileService.UserStatus);
* }*/
if (profileService.UserStatus == UserStatus.LoggedIn)
{
StreamingService streamingService = _connection.SessionContext.StreamingService;
//session.ProfileService.GetProfile("Service");
//_toolStripLabelMaximumRealtimeStreams.Text = "Maximum real-time streams: " + streamingService.MaximumRealtimeDataStreams.ToString();
//_toolStripLabelMaximumPlaybackStreams.Text = "Maximum playback streams: " + streamingService.MaximumPlaybackDataStreams.ToString();
_connection.SessionContext.RecorderEventService.SubscribeRecorderEvents(RecorderEventsOn);
}
else
{
var strtest = aArgs.AuthenticationStatus.ToString();
//Program.ShowErrorMessageBox(this, "You have been logged out - " + aArgs.AuthenticationStatus.ToString(), "Session terminated by host");
InsertLog.AddLog("MirasysVCAInterfaceService OnUserStatusChanged(): logged out : " + strtest);
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
new ManualResetEvent(false).WaitOne(5000);
Disconnect();
Connect();
}));
InsertLog.AddLog("MirasysVCAInterfaceService OnUserStatusChanged():After Connect");
}
});
}
public Streaming(StreamingService serviceInstance)
{
service = serviceInstance;
sharing = new WatchSharing();
timeoutTimer = new Timer()
{
AutoReset = true,
Interval = 1000,
};
timeoutTimer.Elapsed += new ElapsedEventHandler(TimeoutStreamsTick);
timeoutTimer.Start();
ServiceState.Stopping += delegate()
{
foreach (var identifier in Streams.Select(x => x.Value.Identifier).ToList())
{
Log.Warn("Killing stream {0} because of service stop", identifier);
KillStream(identifier);
}
};
}
public Streaming(StreamingService serviceInstance)
{
service = serviceInstance;
sharing = new WatchSharing();
timeoutTimer = new Timer()
{
AutoReset = true,
Interval = 1000,
};
timeoutTimer.Elapsed += new ElapsedEventHandler(TimeoutStreamsTick);
timeoutTimer.Start();
ServiceState.Stopping += delegate()
{
foreach (var identifier in Streams.Select(x => x.Value.Identifier).ToList())
{
StreamLog.Warn(identifier, "Killing stream because of service stop");
KillStream(identifier);
}
};
}
public Streaming(StreamingService serviceInstance)
{
sharing = new WatchSharing();
service = serviceInstance;
ThreadManager.Start("StreamTimeout", TimeoutStreamsWorker);
}
public StreamingServiceController(StreamingService streaming)
{
streamingService = streaming;
}
public Streaming(StreamingService serviceInstance)
{
sharing = new WatchSharing();
service = serviceInstance;
ThreadManager.Start("StreamTimeout", TimeoutStreamsWorker);
}
/// <summary>
/// Set current streaming settings
/// </summary>
/// <param name="service">Service settings</param>
/// <param name="save">Save to disk</param>
public void SetStreamSettings(StreamingService service, bool save)
{
SetStreamingSettings(service, save);
}
protected AmazonStreamInfoSource(string firstPageUrl, StreamingService service, IWebClient webClient)
{
_firstPageUrl = firstPageUrl;
_service = service;
_webClient = webClient;
}
public MainPage()
{
this.InitializeComponent();
Unloaded += MainPage_Unloaded;
movements = new Dictionary <RoverMovementType, Action>
{
[RoverMovementType.Forward] = () => motors.MoveForward(),
[RoverMovementType.ForwardLeft] = () => motors.MoveForwardLeft(),
[RoverMovementType.ForwardRight] = () => motors.MoveForwardRight(),
[RoverMovementType.Backward] = () => motors.MoveBackward(),
[RoverMovementType.BackwardLeft] = () => motors.MoveBackwardLeft(),
[RoverMovementType.BackwardRight] = () => motors.MoveBackwardRight(),
[RoverMovementType.RotateLeft] = () => motors.RotateLeft(),
[RoverMovementType.RotateRight] = () => motors.RotateRight(),
[RoverMovementType.Stop] = () => motors.Stop(),
};
streamingService = new StreamingService();
httpCameraServer = new HttpCameraServer();
httpCameraServer.OnRequestDataAsync(RequestDataAsync);
connection = new RemoteConnection();
connection.OnRoverMovementEvent(RoverMovementEvent);
socket = new LocalConnection();
socket.OnRoverMovementEvent(RoverMovementEvent);
int motor1Pin1Number, motor1Pin2Number, motor2Pin1Number, motor2Pin2Number;
int redPinNumber, greenPinNumber, bluePinNumber;
int triggerPinNumber, echoPinNumber;
switch (DeviceInformation.Type)
{
case DeviceType.MinnowBoardMax:
motor1Pin1Number = 0;
motor1Pin2Number = 1;
motor2Pin1Number = 2;
motor2Pin2Number = 3;
redPinNumber = 4;
greenPinNumber = 5;
bluePinNumber = 6;
triggerPinNumber = 7;
echoPinNumber = 8;
break;
case DeviceType.Colibri:
motor1Pin1Number = 98;
motor1Pin2Number = 103;
motor2Pin1Number = 97;
motor2Pin2Number = 79;
// On Colibri there's not enough Pin on to be used only via GPIO: don't use Multicolor LED.
redPinNumber = greenPinNumber = bluePinNumber = -1;
triggerPinNumber = 133;
echoPinNumber = 101;
break;
case DeviceType.RaspberryPi2:
case DeviceType.RaspberryPi3:
default:
motor1Pin1Number = 27;
motor1Pin2Number = 22;
motor2Pin1Number = 5;
motor2Pin2Number = 6;
redPinNumber = 18;
greenPinNumber = 23;
bluePinNumber = 24;
triggerPinNumber = 12;
echoPinNumber = 16;
break;
}
var motorDriver = new L298nMotorDriver(motor1Pin1Number, motor1Pin2Number, motor2Pin1Number, motor2Pin2Number);
motors = motorDriver.AsLeftRightMotors();
distanceSensor = new Sr04UltrasonicDistanceSensor(triggerPinNumber, echoPinNumber, mode: ReadingMode.Continuous);
// Checks whether the Pin number for Multicolor LED has been specified.
if (redPinNumber > 0)
{
led = new MulticolorLed(redPinNumber, greenPinNumber, bluePinNumber);
}
random = new Random(unchecked ((int)(DateTime.Now.Ticks)));
}
public void AddStreamingService(StreamingService streamingService)
{
StreamingServices.Add(streamingService);
SaveChanges();
}
public MainWindow()
{
db = new StreamingContext();
InitializeComponent();
_streamingService = new StreamingService();
_movie = new Movie();
_serie = new Serie();
_season = new Season();
_episode = new Episode();
stpMovie.DataContext = _movie;
stpSerie.DataContext = _serie;
DataContext = _streamingService;
service = new Service();
service.updateListViewStreamingServices(lvDataBinding);
service.fillComboboxStreamingTjenster(comboboxStreamingtjenester);
service.fillComboboxStreamingTjensterSerie(comboboxStreamingtjenesterSeries);
service.addGenres();
service.fillDetailMovie(listviewDetailMovie);
service.fillGenre(listboxGenreFilm, listboxGenreTabSeries);
service.fill_ListviewFilm(listviewFilm);
service.fill_ListviewSerie(listviewSerie);
// listviewSerieSeasonslist.ItemsSource = db.GetallSeasons();
date_fra.DisplayDateStart = DateTime.Now.Date;
date_til.DisplayDateStart = DateTime.Now.Date;
//db.Movies.RemoveRange(db.Movies.Where(a => a.Titel == a.Titel));
//db.Genres.RemoveRange(db.Genres.Where(a => a.Name == a.Name));
//db.Users.RemoveRange(db.Users.Where(a => a.ID == a.ID));
//db.StreamingServices.RemoveRange(db.StreamingServices.Where(a => a.Name == a.Name));
//returns a single item.
// db.SaveChanges();
List <StreamingService> st = db.GetAllStreamingServices();
// List<Genre> genres = db.GetallGenre();
List <Movie> movies = db.GetallMovies();
List <Serie> series = db.GetAllSeries();
//db.SaveChanges();
//List<Movie> moviesasas = db.GetallMovies();
listviewDetailSerie.ItemsSource = series;
// listviewDetailEpisode.ItemsSource = db.GetAllEpisodes();
}
public AnimeStreamInfo(string animeName, string url, StreamingService service)
{
AnimeName = animeName;
Url = url;
Service = service;
}
public SmartTvFacade()
{
_tv = new Tv();
_radio = new Radio();
_streamingService = new StreamingService();
}
public AmazonPageStreamInfoSource(string url, StreamingService service, IWebClient webClient)
: base(url, AnimeXPath, webClient)
{
_service = service;
}
public static IHtmlContent GetStreamLinksHtml(int malAnimeId, GetRecsViewModel model, IUrlHelper url)
{
List <string> streamLinks = new List <string>();
if (model.StreamsByAnime.ContainsKey(malAnimeId))
{
foreach (streaming_service_anime_map serviceMap in model.StreamsByAnime[malAnimeId]
.OrderBy(map => map.streaming_service_id))
{
StreamingService service = (StreamingService)serviceMap.streaming_service_id;
string imagePath;
string altText;
string titleText;
switch (service)
{
case StreamingService.Crunchyroll:
imagePath = url.Content("Content/crunchyroll_icon.png");
altText = "Crunchyroll";
titleText = "Watch on Crunchyroll";
break;
case StreamingService.Funimation:
imagePath = url.Content("Content/funimation_icon.png");
altText = "Funimation";
titleText = "Watch on Funimation";
break;
case StreamingService.Viz:
imagePath = url.Content("Content/viz_icon.png");
altText = "Viz";
titleText = "Watch on Viz";
break;
case StreamingService.Hulu:
imagePath = url.Content("Content/hulu_icon.png");
altText = "Hulu";
titleText = "Watch on Hulu";
break;
case StreamingService.Viewster:
imagePath = url.Content("Content/viewster_icon.png");
altText = "Viewster";
titleText = "Watch on Viewster";
break;
case StreamingService.Daisuki:
imagePath = url.Content("Content/daisuki_icon.png");
altText = "Daisuki";
titleText = "Watch on Daisuki";
break;
case StreamingService.AnimeNetwork:
imagePath = url.Content("Content/anime_network_icon.png");
altText = "Anime Network";
titleText = "Watch on The Anime Network";
break;
case StreamingService.AmazonPrime:
imagePath = url.Content("Content/amazon_prime_icon.png");
altText = "Amazon Prime";
titleText = "Watch on Amazon Prime";
break;
case StreamingService.AmazonAnimeStrike:
imagePath = url.Content("Content/amazon_anime_strike_icon.png");
altText = "Anime Strike";
titleText = "Watch on Amazon Anime Strike";
break;
case StreamingService.Hidive:
imagePath = url.Content("Content/hidive_icon.png");
altText = "Hidive";
titleText = "Watch on Hidive";
break;
default:
continue;
}
string imgHtml = string.Format(@"<img src={0} title={1} alt={2} />",
AttributeString(imagePath), AttributeString(titleText), AttributeString(altText));
string linkHtml = string.Format(@"<a href={0}>{1}</a>", AttributeString(serviceMap.streaming_url), imgHtml);
streamLinks.Add(linkHtml);
}
}
string linksHtml = string.Join(" ", streamLinks);
return(new HtmlString(linksHtml));
}
public ContentController(StreamingService streaming)
{
streamingService = streaming;
}
