public bool RemoveFromStream(StreamModel model)
{
try
{
var any = _streamUserMapper.Any(model.StreamId);
if (!any)
{
Logger.Warn("Stream not exist!" + model);
return(false);
}
foreach (var connection in _connectionMapper.GetConnections(model.User.UserId))
{
Groups.Remove(connection, model.StreamId);
}
_streamUserMapper.Remove(model.StreamId, model.User.UserId);
model.MembersCount = GetMembersCount(model.StreamId);
Clients.OthersInGroup(model.StreamId).UserLeft(model);
_joined.Remove(model.StreamId, model);
Logger.Debug(LogKey + model);
return(true);
}
catch (Exception e)
{
Logger.Error(e);
return(false);
}
}
public List <StudentLessonModel> GetStudentMissedLessons
(
StudentModel student,
StreamModel stream,
DateTime until
)
{
var lessonModels = stream.StreamLessons.Where
(
lesson =>
lesson.StudentLessons.Any
(
studentLesson =>
studentLesson.student_id == student.id
) &&
lesson.LessonType < LessonType.Attestation &&
lesson.Date < until
);
return(lessonModels
.Select
(
lesson => lesson.StudentLessons.First
(
studentLesson => studentLesson.student_id == student.id
)
)
.Where
(
studentLesson =>
studentLesson.IsLessonMissed
)
.ToList());
}
private async Task <StreamModel> GetStreamAsync(string url, params object[] args)
{
//ToDO wrap stream for service monitor
await CheckForRefreshRequirement();
var response = await client.GetAsync(String.Format(url, args));
if (response.IsSuccessStatusCode)
{
//if (Log.IsDebugEnabled) Log.Debug(String.Format("GetStreamAsync<{0}>({1}) -> {2}", typeof(byte[]).Name, String.Format(url, args), await response.Content.ReadAsStringAsync()));
var Stream = new StreamModel
{
Stream = await response.Content.ReadAsStreamAsync(),
FileName = response.Content.Headers.ContentDisposition.FileName
};
return(Stream);
}
//if (Log.IsInfoEnabled) Log.Info(String.Format("Failed GetStreamAsync<{0}>({1}) -> {2}{3}", typeof(byte[]).Name, String.Format(url, args), await response.Content.ReadAsStringAsync(), response));
throw new ServerException(response);
}
public static List <StreamModel> GetFollowedStreams(string Username)
{
List <StreamModel> streams = new List <StreamModel>();
using (MySqlConnection conn = new MySqlConnection(Configuration["DBConn:ConnectionString"]))
{
MySqlCommand cmd = new MySqlCommand("get_FollowedStreams", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@user_name", Username);
conn.Open();
MySqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
StreamModel stream = new StreamModel();
stream.StreamID = Convert.ToInt32(rdr["StreamID"]);
stream.Title = rdr["StreamTitle"].ToString();
stream.Link = rdr["StreamLink"].ToString();
stream.GameID = Convert.ToInt32(rdr["GameID"]);
streams.Add(stream);
}
conn.Close();
}
return(streams);
}
public IActionResult CreateStream(StreamModel stream)
{
int gameID = DataLibrary.DataAccess.SQLDataAccess.getGameID(stream.GameTitle);
if (gameID < 0)
{
ModelState.AddModelError("Game", "The game was not found. Please check the game and try again.");
}
if (ModelState.IsValid)
{
DataLibrary.Models.StreamModel streamData = new DataLibrary.Models.StreamModel();
streamData.Title = stream.Title;
streamData.Link = stream.Link;
streamData.GameID = gameID;
int streamID = DataLibrary.DataAccess.SQLDataAccess.CreateStream(streamData);
string Username = HttpContext.Session.GetString("Username");
DataLibrary.DataAccess.SQLDataAccess.HostStream(Username, streamID);
return(RedirectToAction("PlayerHome", "Home"));
}
return(View(stream));
}
public async void CreateStream_Pass()
{
var user = Guid.NewGuid();
var video = new VideoModel
{
VideoId = Guid.NewGuid(),
VideoLength = 7,
VideoName = "Test"
};
var request = new RequestModel
{
VideoId = video.VideoId,
UserId = user
};
var streamService = new StreamManagementService();
var result = await streamService.RequestStream(request);
var streamId = streamService.currentStreams.Find(a => a.UserId == user);
var stream = new StreamModel
{
UserId = user,
VideoId = video.VideoId,
StreamId = streamId.StreamId
};
Assert.NotStrictEqual(stream, result);
}
private EmbedBuilder CreateStreamerEmbed(StreamModel streamModel)
{
var a = new EmbedAuthorBuilder()
{
Name = streamModel.Stream,
IconUrl = streamModel.Avatar
};
var eb = new EmbedBuilder()
{
Author = a,
Color = new Color(0, 200, 0),
ThumbnailUrl = streamModel.Avatar,
Title = streamModel.Title,
Url = streamModel.Link
};
eb.AddField(x =>
{
x.IsInline = true;
x.Name = "**Playing:**";
x.Value = streamModel.Game;
});
eb.AddField(x =>
{
x.IsInline = true;
x.Name = "**Viewers:**";
x.Value = streamModel.Viewers;
});
return(eb);
}
public static StreamModel ConvertStreamEntityToModel(Stream entity)
{
StreamModel model = new StreamModel();
//model.name = entity.stream_name;
//model.Url = entity.stream_name;
return(model);
}
/// <summary>
/// Invoked when an item within a group is clicked.
/// </summary>
/// <param name="sender">The GridView (or ListView when the application is snapped)
/// displaying the item clicked.</param>
/// <param name="e">Event data that describes the item clicked.</param>
void ItemView_ItemClick(object sender, ItemClickEventArgs e)
{
// Navigate to the appropriate destination page, configuring the new page
// by passing required information as a navigation parameter
StreamModel streamModel = ((StreamModel)e.ClickedItem);
this.Frame.Navigate(typeof(ItemDetailPage), streamModel);
}
public async void ClickCommand(object sender, object parameter)
{
ItemClickEventArgs arg = parameter as ItemClickEventArgs;
StreamModel item = arg.ClickedItem as StreamModel;
UserModel userLogin = await api.GetUserInfoAsync(item.Id);
localData.Values["User_login"] = userLogin.data.First().login;
NavigationService.Navigate("TwitchClient.ViewModels.MediaViewModel");
}
public IActionResult EditStream(int StreamID)
{
DataLibrary.Models.StreamModel streamData = DataLibrary.DataAccess.SQLDataAccess.GetStreamInfo(StreamID);
StreamModel streamView = new StreamModel();
streamView.StreamID = StreamID;
streamView.GameTitle = DataLibrary.DataAccess.SQLDataAccess.GetGameInfo(streamData.GameID).Title;
streamView.Link = streamData.Link;
streamView.Title = streamData.Title;
return(View(streamView));
}
public void GetCurrentChannelStream()
{
TestWrapper(async(TwitchConnection connection) =>
{
PrivateChannelModel channel = await connection.V5API.Channels.GetCurrentChannel();
Assert.IsNotNull(channel);
StreamModel result = await connection.V5API.Streams.GetChannelStream(channel);
Assert.IsNotNull(result);
Assert.IsTrue(result.id > 0);
});
}
public async void StopStream_Fail()
{
var stream = new StreamModel
{
StreamId = Guid.NewGuid(),
VideoId = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
var streamService = new StreamManagementService();
streamService.CloseStream(stream.StreamId);
Assert.False(streamService.DoesStreamExist(stream.StreamId));
}
public void CalculateCurrentApproach(StreamModel model, int type)
{
MaxApproach = GetMaxTemp(model, type);
for (int i = 1; i <= MaxApproach; i++)
{
getPinchPoint trial = PinchFun(model, i, type);
trial.getCurrentDuties();
if (trial.Qh == trial.CurrentQc)
{
trial.CurrentApproach = i;
}
}
}
private VideoProcessor ReadInternal(StreamModel stream)
{
if (IsClosed(stream))
{
return(new VideoProcessor {
StreamId = stream.Id
});
}
var type = stream.Type;
var streamWorker = stream.StreamWorker;
var videoWorker = stream.VideoPublishWorker;
var enabled = videoWorker.Enabled && streamWorker.Enabled;
StreamState state;
switch (type)
{
case StreamType.LiveCamera:
state = enabled ? StreamState.Processing : StreamState.Ready;
break;
case StreamType.File:
state = stream.InputFileState.Value;
break;
default:
throw new NotSupportedException($"{nameof(StreamType)} {type}");
}
var streamConfig = ApiProvider.StreamWorkerConfigs.Get(streamWorker.Id);
var videoConfig = ApiProvider.VideoPublishWorkerConfigs.Get(videoWorker.Id);
var processor = new VideoProcessor
{
ScopeId = stream.ScopeId,
Enabled = enabled,
StreamId = stream.Id,
Type = type,
State = state
};
Mapper.Map(streamConfig, processor);
Mapper.Map(videoConfig, processor);
return(processor);
}
public static void EditStream(StreamModel stream)
{
using (MySqlConnection conn = new MySqlConnection(Configuration["DBConn:ConnectionString"]))
{
MySqlCommand cmd = new MySqlCommand("update_Stream", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@StreamID", stream.StreamID);
cmd.Parameters.AddWithValue("@Link", stream.Link);
cmd.Parameters.AddWithValue("@Title", stream.Title);
cmd.Parameters.AddWithValue("@GameID", stream.GameID);
conn.Open();
cmd.ExecuteNonQuery();
conn.Close();
}
}
public void GetChannelStream()
{
TestWrapper(async(TwitchConnection connection) =>
{
IEnumerable <StreamModel> results = await connection.V5API.Streams.GetStreams(game: "Fortnite");
Assert.IsNotNull(results);
Assert.IsTrue(results.Count() > 0);
StreamModel result = await connection.V5API.Streams.GetChannelStream(results.First().channel);
Assert.IsNotNull(result);
Assert.IsTrue(result.id > 0);
});
}
public async Task <IActionResult> Stream()
{
var bots = new GetBotsByStatusQuery
{
status = false //offline
};
var botlist = await _mediator.Send(bots);
var model = new StreamModel();
for (int i = 0; i < botlist.Length; i++)
{
model.NewVariables[i].Domain = botlist[i].Domain;
model.NewVariables[i].Name = botlist[i].UserName;
}
return(View(model));
}
public void StreamCount_Fail()
{
var stream = new StreamModel
{
StreamId = Guid.NewGuid(),
VideoId = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
var streamService = new StreamManagementService();
streamService.currentStreams.Add(stream);
streamService.currentStreams.Add(stream);
streamService.currentStreams.Add(stream);
streamService.currentStreams.Add(stream);
Assert.True(streamService.IsUserOverStreamLimit(stream.UserId));
}
/// <summary>
/// Populates the page with content passed during navigation. Any saved state is also
/// provided when recreating a page from a prior session.
/// </summary>
/// <param name="navigationParameter">The parameter value passed to
/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
/// </param>
/// <param name="pageState">A dictionary of state preserved by this page during an earlier
/// session. This will be null the first time a page is visited.</param>
protected async override void LoadState(Object navigationParameter, Dictionary <String, Object> pageState)
{
// Allow saved page state to override the initial item to display
if (pageState != null && pageState.ContainsKey("SelectedItem"))
{
navigationParameter = pageState["SelectedItem"];
}
// TODO: Create an appropriate data model for your problem domain to replace the sample data
StreamModel item = (StreamModel)navigationParameter;
this.DefaultViewModel["Group"] = await Justin.Stream.List();
this.DefaultViewModel["Items"] = item;
this.flipView.SelectedItem = item.id;
}
public void DoesStreamExist_Pass()
{
var newStream = Guid.NewGuid();
var streamService = new StreamManagementService();
var results = new StreamModel
{
UserId = Guid.NewGuid(),
VideoId = Guid.NewGuid(),
StreamId = newStream
};
streamService.currentStreams.Add(results);
var result = streamService.DoesStreamExist(newStream);
Assert.True(result);
}
public async Task <StreamModel> RequestStream(RequestModel request)
{
var overStreamLimitCheck = IsUserOverStreamLimit(request.UserId);
if (!overStreamLimitCheck)
{
var stream = new StreamModel
{
UserId = request.UserId,
VideoId = request.VideoId,
StreamId = Guid.NewGuid()
};
currentStreams.Add(stream);
return(stream);
}
return(null);
}
public async void DeleteStream_Pass()
{
var stream = new StreamModel
{
StreamId = Guid.NewGuid(),
VideoId = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
var streamService = new StreamManagementService();
streamService.currentStreams.Add(stream);
Assert.True(streamService.DoesStreamExist(stream.StreamId));
streamService.CloseStream(stream.StreamId);
Assert.False(streamService.DoesStreamExist(stream.StreamId));
}
public IHttpActionResult postStreamsOptimize(StreamModel model)
{
MaxApproach = GetMaxTemp(model, 0);
List <CostCalc> CostCalcList = new List <CostCalc>();
List <Point> CAPEXLine = new List <Point>();
List <Point> OPEXLine = new List <Point>();
List <Point> TotalCostLine = new List <Point>();
for (int i = 1; i <= MaxApproach; i++)
{
getPinchPoint trial = PinchFun(model, i, 0);
double?HotUtilityCostPerHour = trial.UtilityStreams.Where(a => a.GetType() == typeof(PinchAnalysis_DLL.HotUtilityStream)).Sum(a => a.OptimiumDuty * a.Cost);
double?ColdUtilityCostPerHour = trial.UtilityStreams.Where(a => a.GetType() == typeof(PinchAnalysis_DLL.ColdUtilityStream)).Sum(a => a.OptimiumDuty * a.Cost);
var cold = trial.UtilityStreams.Where(a => a.GetType() == typeof(PinchAnalysis_DLL.ColdUtilityStream));
CostCalc row = new CostCalc(trial.MaxHeatRecovery, trial.Get_Optimium_UA() / 1000000, model.DollarPerUA, model.LifeTime, HotUtilityCostPerHour, ColdUtilityCostPerHour);
CostCalcList.Add(row);
CAPEXLine.Add(new Point(i, row.HourlyCAPEX));
OPEXLine.Add(new Point(i, row.TotalOPEX));
TotalCostLine.Add(new Point(i, row.TotalCost));
Streams.Clear();
UtilityStreams.Clear();
}
var OptimumTotalCost = TotalCostLine.OrderBy(a => a.y).FirstOrDefault();
Point OptimumT = new Point(OptimumTotalCost.x, OptimumTotalCost.y);
dynamic obj = new ExpandoObject();
obj.CAPEXLine = CAPEXLine;
obj.OPEXLine = OPEXLine;
obj.TotalCostLine = TotalCostLine;
obj.OptimumT = OptimumT;
return(Ok(obj));
}
public ActionResult AddStream(StreamModel model, HttpPostedFileBase photo)
{
if (ModelState.IsValid)
{
if (photo != null)
{
string fileName = System.IO.Path.GetFileName(photo.FileName);
string path = "/Content/images1/" + fileName;
photo.SaveAs(Server.MapPath(path));
_hlogic.AddStream(model.ChanelName, model.Link, path, model.Category);
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Загрузите фото!!!");
}
}
return(View(model));
}
public bool Like(StreamModel model)
{
try
{
var any = _streamUserMapper.Any(model.StreamId);
if (!any)
{
Logger.Warn("Stream not exist!" + model);
return(false);
}
Clients.OthersInGroup(model.StreamId).UserLiked(model);
Logger.Debug(LogKey + model);
return(true);
}
catch (Exception e)
{
Logger.Error(e);
return(false);
}
}
public static int CreateStream(StreamModel stream)
{
int streamID = 0;
using (MySqlConnection conn = new MySqlConnection(Configuration["DBConn:ConnectionString"]))
{
MySqlCommand cmd = new MySqlCommand("create_Stream", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@streamLink", stream.Link);
cmd.Parameters.AddWithValue("@streamTitle", stream.Title);
cmd.Parameters.AddWithValue("@gameID", stream.GameID);
conn.Open();
MySqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
streamID = Convert.ToInt32(rdr["StreamID"]);
}
conn.Close();
}
return(streamID);
}
public static StreamModel GetStreamInfo(int StreamID)
{
StreamModel stream = new StreamModel();
using (MySqlConnection conn = new MySqlConnection(Configuration["DBConn:ConnectionString"]))
{
MySqlCommand cmd = new MySqlCommand("get_StreamInfo", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@StreamID", StreamID);
conn.Open();
MySqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
stream.StreamID = Convert.ToInt32(rdr["StreamID"]);
stream.GameID = Convert.ToInt32(rdr["GameID"]);
stream.Title = rdr["StreamTitle"].ToString();
stream.Link = rdr["StreamLink"].ToString();
}
conn.Close();
}
return(stream);
}
private void UpdateLiveStreamModelsAsync(TwitchLib.Api.Helix.Models.Streams.Stream twitchStream,
GetGamesResponse game)
{
string gameName = game.Games.Length != 0 ? game.Games[0].Name : "Unknown";
StreamModel streamModel = new StreamModel()
{
Stream = twitchStream.UserName,
Id = twitchStream.UserId,
Avatar = StreamProfileImages[twitchStream.UserId],
Title = twitchStream.Title,
Game = gameName,
Viewers = twitchStream.ViewerCount,
Link = $"https://www.twitch.tv/{twitchStream.UserName}"
};
if (StreamModels.ContainsKey(twitchStream.UserId))
{
StreamModels.Remove(twitchStream.UserId);
}
StreamModels.Add(twitchStream.UserId, streamModel);
}
public IActionResult EditStream(StreamModel stream)
{
int gameID = DataLibrary.DataAccess.SQLDataAccess.getGameID(stream.GameTitle);
if (gameID < 0)
{
ModelState.AddModelError("Game", "The game was not found. Please check the game and try again.");
}
if (ModelState.IsValid)
{
DataLibrary.Models.StreamModel streamData = new DataLibrary.Models.StreamModel();
streamData.Title = stream.Title;
streamData.Link = stream.Link;
streamData.GameID = gameID;
streamData.StreamID = stream.StreamID;
DataLibrary.DataAccess.SQLDataAccess.EditStream(streamData);
return(RedirectToAction("StreamInfo", "Stream", new { StreamID = stream.StreamID }));
}
return(View(stream));
}
