/// <summary>
/// Default c'tor with predefined Services
/// </summary>
public PredefinedServiceFacade()
{
RequestService = new RequestService();
RequestParameterService = new UrlRequestParameterService();
MappingService = new JsonMapperService();
GeolocationMappingService = new GoogleGeolocationMappingService();
CachingService = new CachingService();
SerializationService = new JsonSerializationService();
ThreadService = new ThreadService();
MailService = new SystemNetMail();
}
/*You can specify device ID by yourself if you have one(it has to be unique per device):
Countly.Init(this, "https://YOUR_SERVER", "YOUR_APP_KEY", "YOUR_DEVICE_ID").*/
public void Init(string Url, string AppKey, string DeviceID)
{
if (string.IsNullOrWhiteSpace(Url)) Url = "https://cloud.count.ly/";
if (Url[Url.Length-1] != '/') Url += "/";
param = new Parameters()
{
app_key = AppKey,
device_id = DeviceID
};
var RequestUrl = Url + "i?" + param.GetParams();//JsonConvert.SerializeObject(param);
// debug value
/*var debugResult = */RequestService ReqService = new RequestService(RequestUrl);
//Debug.Assert(debugResult.Result.result == "success");
}
public int InsertRequestService(RequestService requestService)
{
return(_servicesWorkflow.InsertRequestService(requestService));
}
public PlayStoreService()
{
_requestService = new RequestService();
}
public void CheckAndUpdateAll()
{
var plexSettings = Plex.GetSettings();
if (!ValidateSettings(plexSettings))
{
Log.Debug("Validation of the plex settings failed.");
return;
}
var libraries = CachedLibraries(plexSettings, true); //force setting the cache (10 min intervals via scheduler)
if (libraries == null || !libraries.Any())
{
Log.Debug("Did not find any libraries in Plex.");
return;
}
var movies = GetPlexMovies().ToArray();
var shows = GetPlexTvShows().ToArray();
var albums = GetPlexAlbums().ToArray();
var requests = RequestService.GetAll();
var requestedModels = requests as RequestedModel[] ?? requests.Where(x => !x.Available).ToArray();
if (!requestedModels.Any())
{
Log.Debug("There are no requests to check.");
return;
}
var modifiedModel = new List <RequestedModel>();
foreach (var r in requestedModels)
{
var releaseDate = r.ReleaseDate == DateTime.MinValue ? string.Empty : r.ReleaseDate.ToString("yyyy");
bool matchResult;
switch (r.Type)
{
case RequestType.Movie:
matchResult = IsMovieAvailable(movies, r.Title, releaseDate, r.ImdbId);
break;
case RequestType.TvShow:
if (!plexSettings.EnableTvEpisodeSearching)
{
matchResult = IsTvShowAvailable(shows, r.Title, releaseDate, r.TvDbId, r.SeasonList);
}
else
{
matchResult = r.Episodes.Any() ?
r.Episodes.All(x => IsEpisodeAvailable(r.TvDbId, x.SeasonNumber, x.EpisodeNumber)) :
IsTvShowAvailable(shows, r.Title, releaseDate, r.TvDbId, r.SeasonList);
}
break;
case RequestType.Album:
matchResult = IsAlbumAvailable(albums, r.Title, r.ReleaseDate.Year.ToString(), r.ArtistName);
break;
default:
throw new ArgumentOutOfRangeException();
}
if (matchResult)
{
r.Available = true;
modifiedModel.Add(r);
continue;
}
}
Log.Debug("Requests that will be updated count {0}", modifiedModel.Count);
if (modifiedModel.Any())
{
NotificationEngine.NotifyUsers(modifiedModel, plexSettings.PlexAuthToken);
RequestService.BatchUpdate(modifiedModel);
}
Job.Record(JobNames.PlexChecker);
}
public VolunteerController(UserService userService, EmployeeService employeeService,
VolunteerService volunteerService, WorkShopService shopService, AssignWorkShopService assignWorkShopService, NotificationService notificationService, RequestService requestService, AssignedRequestService assignedRequest)
{
_userService = userService;
_employeeService = employeeService;
_volunteerService = volunteerService;
_requestService = requestService;
_assignedRequest = assignedRequest;
_notificationService = notificationService;
_workshopService = shopService;
_assignworkShopService = assignWorkShopService;
}
public RequestsController(DataContext context)
{
_service = new RequestService(context);
}
public RequestDto[] Get()
{
Log("GetAllRequests");
return(RequestService.GetAllRequests());
}
public static List <User> GetUsersFollowersByUserName(string userId)
{
Message.Info("---------Starting Instagram method [GetUsersFollowersByUserName()]----------");
Message.Info("------------------------------------------------");
List <User> userFollowersList = new List <User>();
List <User> finalUserList = new List <User>();
Random rnd = new Random();
List <string> usersNameList = new List <string>();
Browser brow = new Browser();
string FirefoxProfileRoute = @"C:\Users\LENOVO\AppData\Roaming\Mozilla\Firefox\Profiles\rajnbzdv.default";
brow.ExecuteFirefox("https://www.instagram.com/", FirefoxProfileRoute);
CheckIfWeAreLoged(brow.DriverFirefox);
Thread.Sleep(rnd.Next(33, 77));
string urlRequestFollowersBase = "https://www.instagram.com/graphql/query/?query_hash=c56ee0ae1f89cdbd1c89e2bc6b8f3d18&variables=%7B%22id%22%3A%22{0}%22%2C%22include_reel%22%3Atrue%2C%22fetch_mutual%22%3Afalse%2C%22first%22%3A49%7D";
string urlRequest = string.Format(urlRequestFollowersBase, userId);
brow.DriverFirefox.Navigate().GoToUrl(urlRequest);
Thread.Sleep(rnd.Next(3333, 9111));
Message.Info("Trying to do click in 'Datos sin procesar' button for extract the json element. [()]");
#region Doing click in 'data without proccess' button
List <string> xpathRoutesProcessDataButton = new List <string>();
xpathRoutesProcessDataButton.Add("//ul[@class='tabs-menu']/li[2]");
xpathRoutesProcessDataButton.Add("//a[contains(text(),'Datos sin procesar')]");
List <IWebElement> ProcessWithoutFormatPageElements = new List <IWebElement>();
foreach (var xpathRoute in xpathRoutesProcessDataButton)
{
ProcessWithoutFormatPageElements = brow.DriverFirefox.FindElements(By.XPath(xpathRoute)).ToList();
if (ProcessWithoutFormatPageElements.Count() > 0)
{
Message.Info(string.Format("Route valid: {0}. [GetOwnFollowersToUpdateFast()]", xpathRoute));
ProcessWithoutFormatPageElements[0].Click();
Thread.Sleep(rnd.Next(4444, 9999));
break;
}
}
if (ProcessWithoutFormatPageElements.Count() == 0)
{
Message.Info("------------------");
Message.Info("Is not posible found 'process data' button. [GetOwnFollowersToUpdateFast()]");
Message.Info("------------------");
}
#endregion
Thread.Sleep(rnd.Next(4444, 9999));
var jsonElement = brow.DriverFirefox.FindElement(By.XPath("//pre"));
dynamic json = JsonConvert.DeserializeObject(jsonElement.GetAttribute("textContent"));
foreach (var followerData in json["data"]["user"]["edge_follow"]["edges"])
{
var isPrivateUser = followerData["node"]["is_private"];
if (!Boolean.Parse(isPrivateUser.ToString()))
{
//User user = new User();
//user.Name = followerData["node"]["username"];
//userFollowersList.Add(user);
}
else
{
//Message.Info("User provate, descarted.");
}
User user = new User();
user.Name = followerData["node"]["username"];
userFollowersList.Add(user);
}
brow.DriverFirefox.Close();
brow.DriverFirefox.Quit();
RequestService serviceRequest = new RequestService();
foreach (var user in userFollowersList)
{
string urlRequestUser = string.Format("https://www.instagram.com/{0}/", user.Name);
var sourceHtmlText = serviceRequest.GetSourceHtmlCodeOfUrl(urlRequestUser);
int initIndex = sourceHtmlText.IndexOf("window._sharedData = ");
string auxiliarText = sourceHtmlText.Substring(initIndex);
int indexCommaPoint = auxiliarText.IndexOf(";");
auxiliarText = auxiliarText.Substring(0, indexCommaPoint);
string stringJsonContentUserFormatted = auxiliarText.Replace("window._sharedData = ", "").Replace(";", "");
dynamic jsonContentUser = null;
try
{
jsonContentUser = JsonConvert.DeserializeObject(stringJsonContentUserFormatted);
}
catch (Exception e)
{
jsonContentUser = null;
}
Thread.Sleep(rnd.Next(87, 227));
if (jsonContentUser != null)
{
Message.Info("- Getting data to check is user not exceed the requeriments(followers/s number). [GetUsersByHashtagAndLocation()]");
#region Getting data of user
var jsonAuthor = jsonContentUser["entry_data"]["ProfilePage"][0];
int follows = jsonAuthor["graphql"]["user"]["edge_follow"]["count"];
int followers = jsonAuthor["graphql"]["user"]["edge_followed_by"]["count"];
var isBusinessNode = jsonAuthor["graphql"]["user"]["is_business_account"];
#endregion
Message.Info("- Trying to complete the user data with the extra information. [GetUsersByHashtagAndLocation()]");
//Creating a user and adding to userList
if (followers < follows)
{
finalUserList.Add(user);
}
}
}
return(finalUserList);
}
public void CallDisconnectLocalFileStreamOnIMediaPlayer(
[Frozen] IMediaPlayer mediaPlayer, Stream outStream, BaseRequest message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
mediaPlayer.Received(1).DisconnectLocalFileStream();
}
public void ReturnFalseIfInvalidMessage(IMediaPlayer mediaPlayer, Stream inStream,
Stream outStream, BaseRequest message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream).Should()
.BeFalse("Because it's an invalid message.");
}
public void CallReturnEmptyResponseOnIResponseService([Frozen] IResponseService responseService,
IMediaPlayer mediaPlayer, Stream outStream, BaseRequest message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
responseService.Received(1).ReturnEmptyResponse(outStream, message);
}
public void CallReturnResultResponseOnIResponseServiceForGetVideoTracks([Frozen] IResponseService responseService,
IMediaPlayer mediaPlayer, Stream outStream, GetVideoTracks message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
responseService.Received(1).ReturnResultResponse(outStream, message, Arg.Any <List <(int, string)> >());
}
public void CallReturnResultResponseOnIResponseServiceForCreateSnapshot([Frozen] IResponseService responseService,
IMediaPlayer mediaPlayer, Stream outStream, CreateSnapshot message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
responseService.Received(1).ReturnResultResponse(outStream, message, Arg.Any <bool>());
}
public void CallReturnResultResponseOnIResponseServiceForLocalFileStreamConnect([Frozen] IResponseService responseService,
IMediaPlayer mediaPlayer, Stream outStream, LocalFileStreamConnect message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
responseService.Received(1).ReturnResultResponse(outStream, message, true);
}
public void ReturnTrueIfQuitMessage(Stream inStream, Stream outStream, Quit message,
IMediaPlayer mediaPlayer, RequestService sut)
{
sut.IsQuitMessage(message).Should().BeTrue();
}
public void CallSetPlaybackSpeedOnIMediaPlayer([Frozen] IMediaPlayer mediaPlayer,
Stream outStream, SetPlaybackSpeed message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
mediaPlayer.Received(1).SetPlaybackSpeed(message.Speed);
}
public RequestDto Get(string id)
{
Log($"GetRequest. {HttpContext.Request.Path}");
return(RequestService.GetRequest(id));
}
public void CallStepForwardOnIMediaPlayer([Frozen] IMediaPlayer mediaPlayer,
Stream outStream, BaseRequest message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
mediaPlayer.Received(1).StepForward();
}
public UpdateInfoRequestController(UserService userService, FormService formService, RequestService requestService,
SystemService systemService, OrganizationService orgnizationService, IAuthorizationService authService,
TreeViewService treeViewService, ILogger <UpdateInfoRequestController> logger)
: base(userService, formService, requestService, systemService, orgnizationService, authService, treeViewService, logger)
{
}
public RequestController(InnerCircleDataContext context)
{
_context = context;
RequestService = new RequestService(context);
}
public void CheckAndUpdateAll()
{
var embySettings = Emby.GetSettings();
if (!embySettings.Enable)
{
return;
}
if (!ValidateSettings(embySettings))
{
Log.Debug("Validation of the Emby settings failed.");
return;
}
var content = EmbyContent.GetAll().ToList();
var movies = GetEmbyMovies(content).ToArray();
var shows = GetEmbyTvShows(content).ToArray();
var albums = GetEmbyMusic(content).ToArray();
var requests = RequestService.GetAll();
var requestedModels = requests as RequestedModel[] ?? requests.Where(x => !x.Available).ToArray();
if (!requestedModels.Any())
{
Log.Debug("There are no requests to check.");
return;
}
var modifiedModel = new List <RequestedModel>();
foreach (var r in requestedModels)
{
var releaseDate = r.ReleaseDate == DateTime.MinValue ? string.Empty : r.ReleaseDate.ToString("yyyy");
bool matchResult;
switch (r.Type)
{
case RequestType.Movie:
matchResult = IsMovieAvailable(movies, r.Title, releaseDate, r.ImdbId);
break;
case RequestType.TvShow:
if (!embySettings.EnableEpisodeSearching)
{
matchResult = IsTvShowAvailable(shows, r.Title, releaseDate, r.TvDbId, r.SeasonList);
}
else
{
matchResult = r.Episodes.Any() ?
r.Episodes.All(x => IsEpisodeAvailable(r.TvDbId, x.SeasonNumber, x.EpisodeNumber)) :
IsTvShowAvailable(shows, r.Title, releaseDate, r.TvDbId, r.SeasonList);
}
break;
case RequestType.Album:
//matchResult = IsAlbumAvailable(albums, r.Title, r.ReleaseDate.Year.ToString(), r.ArtistName); // TODO Emby
matchResult = false;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (matchResult)
{
r.Available = true;
modifiedModel.Add(r);
continue;
}
}
Log.Debug("Requests that will be updated count {0}", modifiedModel.Count);
if (modifiedModel.Any())
{
NotificationEngine.NotifyUsers(modifiedModel, NotificationType.RequestAvailable);
RequestService.BatchUpdate(modifiedModel);
}
}
public void CreateDependencies()
{
_assignedRequest = new Request()
{
RequestId = 1,
CreatedDate = DateTime.Now.AddDays(-1).Date,
EndDate = DateTime.Today.AddDays(10).Date,
Description = "Assigned Request",
CreatorId = 1,
AssigneeId = 2,
Completed = false,
Location = "B"
};
_unassignedRequest = new Request()
{
RequestId = 2,
CreatedDate = DateTime.Now.AddDays(-2).Date,
EndDate = DateTime.Today.AddDays(20).Date,
Description = "Unassigned Request",
CreatorId = 1,
Completed = false,
Location = "A"
};
_completedRequest = new Request()
{
RequestId = 3,
CreatedDate = DateTime.Now.AddDays(-3).Date,
EndDate = DateTime.Today.AddDays(30).Date,
Description = "Completed Request",
CreatorId = 1,
AssigneeId = 2,
Completed = true,
Location = "C"
};
var data = new List<Request>
{
_assignedRequest,
_unassignedRequest,
_completedRequest
}.AsQueryable();
_requestList = data;
// prepare mock queryable set the implements DbAsyncQueryProvider
_mockSet = new Mock<IQueryable<Request>>();
_mockSet.As<IDbAsyncEnumerable<Request>>()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator<Request>(data.GetEnumerator()));
_mockSet.As<IQueryable<Request>>()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider<Request>(data.Provider));
_mockSet.As<IQueryable<Request>>().Setup(m => m.Expression).Returns(data.Expression);
_mockSet.As<IQueryable<Request>>().Setup(m => m.ElementType).Returns(data.ElementType);
_mockSet.As<IQueryable<Request>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
// Set up the data service
_mockDataService = new Mock<IDataService>();
_mockDataService.Setup(c => c.Requests).Returns(_mockSet.Object);
// set up request service
_requestService = new RequestService(_mockDataService.Object);
}
public void Start()
{
JobRecord.SetRunning(true, JobNames.PlexUserChecker);
try
{
var settings = PlexSettings.GetSettings();
if (string.IsNullOrEmpty(settings.PlexAuthToken) || !settings.Enable)
{
return;
}
var plexUsers = PlexApi.GetUsers(settings.PlexAuthToken);
var userManagementSettings = UserManagementSettings.GetSettings();
var mainPlexAccount = PlexApi.GetAccount(settings.PlexAuthToken);
var requests = RequestService.GetAll().ToList();
var dbUsers = Repo.GetAll().ToList();
var localUsers = LocalUserRepository.GetAll().ToList();
// Regular users
foreach (var user in plexUsers.User)
{
var dbUser = dbUsers.FirstOrDefault(x => x.PlexUserId == user.Id);
if (dbUser != null)
{
// We already have the user, let's check if they have updated any of their info.
var needToUpdate = false;
var usernameChanged = false;
if (!string.IsNullOrEmpty(user.Username)) // If true then this is a managed user, we do not want to update the email since Managed Users do not have email addresses
{
// Do we need up update any info?
if (!dbUser.EmailAddress.Equals(user.Email, StringComparison.CurrentCultureIgnoreCase))
{
dbUser.EmailAddress = user.Email;
needToUpdate = true;
}
}
if (!dbUser.Username.Equals(user.Title, StringComparison.CurrentCultureIgnoreCase))
{
needToUpdate = true;
usernameChanged = true;
}
if (needToUpdate)
{
if (usernameChanged)
{
// The username has changed, let's check if the username matches any local users
var localUser = localUsers.FirstOrDefault(x => x.UserName.Equals(user.Title, StringComparison.CurrentCultureIgnoreCase));
dbUser.Username = user.Title;
if (localUser != null)
{
// looks like we have a local user with the same name...
// We should delete the local user and the Plex user will become the master,
// I am not going to update the Plex Users permissions as that could end up leading to a security vulnerability
// Where anyone could change their Plex Username to the PR.Net server admins name and get all the admin permissions.
LocalUserRepository.Delete(localUser);
}
// Since the username has changed, we need to update all requests with that username (unless we are using the alias! Since the alias won't change)
if (string.IsNullOrEmpty(dbUser.UserAlias))
{
// Update all requests
var requestsWithThisUser = requests.Where(x => x.RequestedUsers.Contains(user.Username)).ToList();
foreach (var r in requestsWithThisUser)
{
r.RequestedUsers.Remove(user.Title); // Remove old
r.RequestedUsers.Add(dbUser.Username); // Add new
}
if (requestsWithThisUser.Any())
{
RequestService.BatchUpdate(requestsWithThisUser);
}
}
}
Repo.Update(dbUser);
}
continue;
}
// Looks like it's a new user!
var m = new PlexUsers
{
PlexUserId = user.Id,
Permissions = UserManagementHelper.GetPermissions(userManagementSettings),
Features = UserManagementHelper.GetFeatures(userManagementSettings),
UserAlias = string.Empty,
EmailAddress = user.Email,
Username = user.Title,
LoginId = Guid.NewGuid().ToString()
};
Repo.Insert(m);
}
// Main Plex user
var dbMainAcc = dbUsers.FirstOrDefault(x => x.Username.Equals(mainPlexAccount.Username, StringComparison.CurrentCulture));
var localMainAcc = localUsers.FirstOrDefault(x => x.UserName.Equals(mainPlexAccount.Username, StringComparison.CurrentCulture));
// TODO if admin acc does exist, check if we need to update it
// Create the local admin account if it doesn't already exist
if (dbMainAcc == null && localMainAcc == null)
{
var a = new PlexUsers
{
PlexUserId = mainPlexAccount.Id,
Permissions = UserManagementHelper.GetPermissions(userManagementSettings),
Features = UserManagementHelper.GetFeatures(userManagementSettings),
UserAlias = string.Empty,
EmailAddress = mainPlexAccount.Email,
Username = mainPlexAccount.Username,
LoginId = Guid.NewGuid().ToString()
};
a.Permissions += (int)Permissions.Administrator; // Make admin
Repo.Insert(a);
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
JobRecord.SetRunning(false, JobNames.PlexUserChecker);
JobRecord.Record(JobNames.PlexUserChecker);
}
}
private async Task <Response> ReportRequestIssue(int requestId, IssueState issue, string comment)
{
var model = new IssueModel
{
Issue = issue,
UserReported = Username,
UserNote = !string.IsNullOrEmpty(comment)
? $"{Username} - {comment}"
: string.Empty,
};
var request = await RequestService.GetAsync(requestId);
var issueEntity = await IssuesService.GetAllAsync();
var existingIssue = issueEntity.FirstOrDefault(x => x.RequestId == requestId);
var notifyModel = new NotificationModel
{
User = Username,
NotificationType = NotificationType.Issue,
Title = request.Title,
DateTime = DateTime.Now,
Body = issue == IssueState.Other ? comment : issue.ToString().ToCamelCaseWords()
};
// An issue already exists
if (existingIssue != null)
{
if (existingIssue.Issues.Any(x => x.Issue == issue))
{
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "This issue has already been reported!"
}));
}
existingIssue.Issues.Add(model);
var result = await IssuesService.UpdateIssueAsync(existingIssue);
await NotificationService.Publish(notifyModel);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true
}
: new JsonResponseModel {
Result = false
}));
}
// New issue
var issues = new IssuesModel
{
Title = request.Title,
PosterUrl = request.PosterPath,
RequestId = requestId,
Type = request.Type,
IssueStatus = IssueStatus.PendingIssue
};
issues.Issues.Add(model);
var issueId = await IssuesService.AddIssueAsync(issues);
request.IssueId = issueId;
await RequestService.UpdateRequestAsync(request);
await NotificationService.Publish(notifyModel);
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
static void Main(string[] args)
{
RequestService reqService = new RequestService();
Parameters commons = new Parameters();
while (true)
{
Console.WriteLine();
ShowUserMenu();
switch (Console.ReadKey().Key)
{
case ConsoleKey.N:
Console.WriteLine();
Console.WriteLine("+++++++");
Console.Write("Enter Name : ");
var nameBrewery =
reqService.RequestByName(Console.ReadLine()).Result;
if (nameBrewery.Count() != 0)
{
MoveToBinFile(nameBrewery, commons.filePathName);
PrintList(nameBrewery);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("No items found.");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case ConsoleKey.C:
Console.WriteLine();
Console.WriteLine("+++++++");
Console.Write("Enter city : ");
var cityBrewery = reqService.RequestDataByCity(Console.ReadLine()).Result;
if (cityBrewery.Count() != 0)
{
MoveToBinFile(cityBrewery, commons.filePathCity);
PrintList(cityBrewery);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("No items found.");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case ConsoleKey.T:
Console.WriteLine();
Console.WriteLine("+++++++");
var typeBrewery = reqService.RequestByType().Result;
if (typeBrewery.Count() != 0)
{
MoveToBinFile(typeBrewery, commons.filePathType);
PrintList(typeBrewery);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("No items found.");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case ConsoleKey.F:
var fullList = reqService.RequestFullList().Result;
MoveToBinFile(fullList, commons.filePathFull);
PrintList(fullList);
break;
case ConsoleKey.O:
Console.Clear();
FileMenuPrint();
switch (Console.ReadKey().Key)
{
case ConsoleKey.A:
PrintList(GetFromBin(commons.filePathName));
break;
case ConsoleKey.I:
PrintList(GetFromBin(commons.filePathCity));
break;
case ConsoleKey.Y:
PrintList(GetFromBin(commons.filePathType));
break;
default:
Console.WriteLine("Error! Wrong key entered.");
break;
}
break;
case ConsoleKey.E:
Environment.Exit(0);
break;
default:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error! Wrong key entered.");
Console.ForegroundColor = ConsoleColor.White;
break;
}
}
}
public void AddProperty(HomeAwayPropertyModel model)
{
RequestService service = new RequestService();
service.AddProperty(model);
}
public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
{
Log.ErrorExt($"#{ClientSettings.ClientSession.SessionId}: Caught exception", exception);
RequestService.ReturnException(exception);
}
public void AddFeedback(UserFeedbackModel model)
{
RequestService service = new RequestService();
service.AddUserFeedback(model);
}
public int UpdateRequestServiceStatus(RequestService requestService)
{
return(_servicesWorkflow.UpdateRequestServiceStatus(requestService));
}
public IList <HomeAwayPropertyModel> GetPropertyList()
{
RequestService service = new RequestService();
return(service.GetProperty());
}
public HomeAwayPropertyModel GetProperty(int id)
{
RequestService service = new RequestService();
return(service.GetProperty(id).FirstOrDefault());
}
public void CallGetVideoTracksOnIMediaPlayer([Frozen] IMediaPlayer mediaPlayer,
Stream outStream, GetVideoTracks message, RequestService sut)
{
sut.CanHandleMessage(mediaPlayer, message, outStream);
mediaPlayer.Received(1).GetVideoTracks();
}
