public IEnumerable <QuoteFmItem> updateRecommendations()
{
decimal maxKnownId = 0;
List <QuoteFmItem> newQuoteFmItems = new List <QuoteFmItem>();
if (Recommendations.Count > 0)
{
maxKnownId = Recommendations.Max(r => r.Id);
}
ListOfRecommendations listOfRecommendations = QuoteSharp.API.getRecommendationsListByUser(this.username);
if (listOfRecommendations != null)
{
if (listOfRecommendations.entities.Count() > 0)
{
IEnumerable <Recommendation> newRecommendations = listOfRecommendations.entities.Where(r => r.id > maxKnownId);
foreach (Recommendation recommendation in newRecommendations)
{
QuoteFmItem newItem = QuoteFmItem.createFromApi(recommendation);
if (newItem != null)
{
Recommendations.Add(newItem);
newQuoteFmItems.Add(newItem);
}
}
}
}
return(newQuoteFmItems);
}
/// <summary>
/// This uses fahrenheit values to determine recommendations
/// </summary>
public void SetRecommendations()
{
IList <string> recommendations = new List <string>();
if (Forecast == "snow")
{
Recommendations.Add("Pack some snow shoes.");
}
if (Forecast == "rain")
{
Recommendations.Add("Pack rain gear and wear waterproof shoes.");
}
if (Forecast == "thunderstorms")
{
Recommendations.Add("Seek shelter and avoid hiking on exposed ridges.");
}
if (Forecast == "sun")
{
Recommendations.Add("Don't forget to wear sunblock.");
}
if (High > 75)
{
Recommendations.Add("Bring an extra gallon of water.");
}
if (High - Low > 20)
{
Recommendations.Add("Wear breathable layers.");
}
if (Low < 20)
{
Recommendations.Add("Garry says to stay home - it's cold out there.");
}
}
public void LoadRecommendations()
{
var context = TaskScheduler.FromCurrentSynchronizationContext();
IsBusy = true;
Recommendations.Clear();
Task.Factory.StartNew(() =>
{
var users = dataLoader.LoadFollowings(settings.Username);
var token = Task.Factory.CancellationToken;
foreach (
var recommendation in
readLaterManager.GetReadLaterRecommendations().Select(
recommendationId =>
dataLoader.GetRecommendationById(recommendationId)))
{
var current = recommendation;
Task.Factory.StartNew(() => Recommendations.Add(
RecommendationViewModel.FromModel(
current,
users.Followings.Single(
c => c.Id == current.UserId),
settings.Font)), token,
TaskCreationOptions.None, context);
}
}).ContinueWith(_ => IsBusy = false, context);
}
/// <summary>
/// copy constructor
/// </summary>
/// <param name="n"></param>
public Nanny(Nanny n)
{
ID = n.id;
Floor = n.Floor;
Address = n.Address;
BirthDate = n.BirthDate;
Elevator = n.Elevator;
Expertise = n.Expertise;
FirstName = n.FirstName;
HourSalary = n.HourSalary;
IsCostByHour = n.IsCostByHour;
LastName = n.LastName;
MaxAge = n.MaxAge;
MaxChildren = n.MaxChildren;
MinAge = n.MinAge;
MonthSalary = n.MonthSalary;
Phone = n.Phone;
VacationByMinisterOfEducation = n.VacationByMinisterOfEducation;
for (int i = 0; i < 6; i++)
{
WorkDays[i] = n.WorkDays[i];
WorkHours[0, i] = n.WorkHours[0, i];
WorkHours[1, i] = n.WorkHours[1, i];
}
WorkDays[6] = n.WorkDays[6];
foreach (string str in n.Recommendations)
{
Recommendations.Add(str);
}
}
public virtual void RemoveFromQueue(Book book)
{
Queue.Remove(book);
// if it was on the queue, it probably means that the user
// might want to read it again, so let us recommend it
Recommendations.Add(book);
// add any other business logic related to removing book from queue
}
private void RecommendHighNumberOfThreads()
{
if (Threads.Count > 200)
{
Recommendations.Add(new HighNumberOfThreads {
Count = Threads.Count
});
}
}
private void RecommendFinalizerThreadBlocked(CommandExecutionContext context)
{
var finalizerThread = context.Runtime.Threads.SingleOrDefault(t => t.IsFinalizer);
var threadWithLocks = Threads.SingleOrDefault(t => t.OSThreadId == finalizerThread?.OSThreadId);
if (threadWithLocks != null && threadWithLocks.Locks.Any() && threadWithLocks.IsRunningManagedCode())
{
Recommendations.Add(new FinalizerThreadBlocked(threadWithLocks));
}
}
public bool AddVideo(Video video)
{
if (Recommendations.Any(v => v.Id == video.Id))
{
return(false);
}
Recommendations.Add(video);
return(true);
}
/// <summary>
/// initializes a nanny with the given parameters
/// </summary>
/// <param name="id">ID</param>
/// <param name="fname">first name</param>
/// <param name="lname">last name</param>
/// <param name="phone">phone number</param>
/// <param name="address">address</param>
/// <param name="birth">birth date</param>
/// <param name="elevator">does the nanny have elevator?</param>
/// <param name="byHour">does the nanny get paid by hour?</param>
/// <param name="byedu">does the nanny get vacations according to the minister of education?</param>
/// <param name="floor">the floor the nanny lives in</param>
/// <param name="maxchildren">the maximum number of contracts the nanny can have signed at once</param>
/// <param name="minage">minimal acceptable age for a child (by months)</param>
/// <param name="maxage">maximal acceptable age for a child (by months)</param>
/// <param name="hsal">salary per hour</param>
/// <param name="msal">salary per month</param>
/// <param name="exp">years of expertise</param>
/// <param name="days">days in which the nanny works</param>
/// <param name="hours">hours in which the nanny works (first one is starting our, second is ending hour) per day</param>
/// <param name="recs">reccomendations</param>
public Nanny(string id, string fname, string lname, string phone, string address, DateTime birth, bool elevator, bool byHour, bool byedu, int floor, int maxchildren, int minage, int maxage, int hsal, int msal, int exp, bool[] days, DateTime[,] hours, List <string> recs)
{
ID = id;
FirstName = fname;
LastName = lname;
Phone = phone;
Address = address;
BirthDate = birth;
Elevator = elevator;
IsCostByHour = byHour;
VacationByMinisterOfEducation = byedu;
Floor = floor;
MaxChildren = maxchildren;
MaxAge = maxage;
MinAge = minage;
HourSalary = hsal;
MonthSalary = msal;
Expertise = exp;
//workDays = days;
if (days.Length == 7)
{
for (int i = 0; i < workDays.Length; i++)
{
WorkDays[i] = days[i];
}
}
else
{
throw new Exception("days array must have the length of 7");
}
//workHours = hours;
if (hours.GetLength(0) == 2 && hours.GetLength(1) == 6)
{
for (int i = 0; i < 6; i++)
{
if (WorkDays[i])
{
WorkHours[0, i] = hours[0, i];
WorkHours[1, i] = hours[1, i];
}
}
}
else
{
throw new Exception("hours matrix must be of size [2,6]");
}
for (int i = 0; recs != null && i < recs.Count; i++)
{
Recommendations.Add(recs[i]);
}
}
private void RecommendFinalizerThreadHighCPU(CommandExecutionContext context)
{
var finalizerThread = context.Runtime.Threads.SingleOrDefault(t => t.IsFinalizer);
var info = Threads.SingleOrDefault(t => t.OSThreadId == finalizerThread.OSThreadId);
ulong executionTimeIn100Ns = info.KernelTime + info.UserTime;
ulong totalTimeIn100Ns = _processUpTimeInSeconds * SEC_TO_100NSEC;
double executionPercent = 100.0 * executionTimeIn100Ns / totalTimeIn100Ns;
if (executionPercent > 5.0)
{
Recommendations.Add(new FinalizerThreadHighCPU {
ExecutionPercent = executionPercent
});
}
}
void recsWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
VM_AnimeSeries_User ser = e.Argument as VM_AnimeSeries_User;
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Recommendations.Clear();
});
List <VM_AniDB_Anime_Similar> tempList = VM_ShokoServer.Instance.ShokoServices.GetSimilarAnimeLinks(ser.AniDB_ID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID).Cast <VM_AniDB_Anime_Similar>().OrderByDescending(a => a.AnimeID).ToList();
foreach (VM_AniDB_Anime_Similar sim in tempList)
{
if (!sim.AnimeInfoExists)
{
string result = VM_ShokoServer.Instance.ShokoServices.UpdateAnimeData(sim.SimilarAnimeID);
if (string.IsNullOrEmpty(result))
{
sim.PopulateAnime((VM_AniDB_Anime)VM_ShokoServer.Instance.ShokoServices.GetAnime(sim.SimilarAnimeID));
}
}
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Recommendations.Add(new RecommendationTile()
{
Details = "",
AnimeName = sim.DisplayName,
Picture = sim.PosterPath,
AnimeSeries = sim.AnimeSeries,
TileSize = "Large",
Height = 100,
Source = "AniDB",
AnimeID = sim.AnimeID,
URL = sim.AniDB_SiteURL,
SimilarAnimeID = sim.SimilarAnimeID,
HasSeries = sim.LocalSeriesExists
});
});
}
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
}
private void Update(IList <StatusReportItem> freshReport)
{
_report.Clear();
Items.Clear();
Recommendations.Clear();
RecommendationsVisibility = Visibility.Collapsed;
// scan all items for status codes, even if filtered
StatusReportItem.SeverityCode newStatus = freshReport
.Select(item => item.Severity)
.DefaultIfEmpty(StatusReportItem.SeverityCode.None)
.Max();
// filter report
_report.AddRange(freshReport.Where(i => i.Severity >= _displayThreshold));
if (_report.Count < 1)
{
// done
SetStatus(newStatus);
UpdateDetailsVisibility();
return;
}
// create a unique set of recommendations
HashSet <string> uniqueRecommendations = new HashSet <string>(
_report.Select(item => item.Recommendation).Where(text => !string.IsNullOrEmpty(text)),
StringComparer.OrdinalIgnoreCase);
foreach (string recommendation in uniqueRecommendations)
{
Recommendations.Add(recommendation);
RecommendationsVisibility = Visibility.Visible;
}
// create view models for status items
IEnumerable <InterfaceStatusViewItem> checklistItems = _report
.Select(item => new InterfaceStatusViewItem(item));
foreach (InterfaceStatusViewItem checklistItem in checklistItems)
{
Items.Add(checklistItem);
}
SetStatus(newStatus);
UpdateDetailsVisibility();
}
/// <summary>
/// Конструктор по умолчанию.
/// </summary>
public AudiosViewModel(string uniqueKey, long ownerID)
: base(uniqueKey)
{
_audios = new AudiosCollection(ownerID);
_recommendations = new RecommendedAudiosCollection((ulong)ownerID);
_popular = new PopularAudiosCollection();
_albums = new AudioAlbumsCollection(ownerID);
Refresh = new RelayCommand(() => Audios.Refresh());
RefreshAlbums = new RelayCommand(() => Albums.Refresh());
RefreshPopular = new RelayCommand(() => Popular.Refresh());
RefreshRecommended = new RelayCommand(() => Recommendations.Refresh());
DeleteCommand = new RelayCommand <VKAudio>(async audio =>
{
var request = new Request.DeleteAudioRequest(audio.ID, audio.OwnerID);
var response = await request.ExecuteAsync();
if (response.Error.ErrorType == VKErrors.None)
{
Audios.Remove(audio);
}
else
{
await ServiceHelper.DialogService.ShowMessageBox("Произошла ошибка: " + response.Error.ErrorType.ToString(),
"Не удалось удалить аудиозапись.");
}
});
DownloadAudio = new RelayCommand <VKAudio>(async audio =>
{
var command = new VKSaverDownloadCommand();
command.Downloads.Add(CoreHelper.GetDownload(audio));
await command.TryExecute();
});
#if DEBUG
if (ViewModelBase.IsInDesignModeStatic)
{
for (int i = 0; i < 71; i++)
{
Audios.Add(DesignDataHelper.GetAudio());
Recommendations.Add(DesignDataHelper.GetAudio());
Popular.Add(DesignDataHelper.GetAudio());
}
}
#endif
}
public override bool Generate(CommandExecutionContext context)
{
if (context.TargetType == TargetType.DumpFileNoHeap)
{
return(false);
}
LargeObjectHeapSize = context.Heap.GetSizeByGen(3);
var freeSpaceBySegment = context.Heap.GetFreeSpaceBySegment();
foreach (var segment in context.Heap.Segments)
{
ulong free;
if (!freeSpaceBySegment.TryGetValue(segment, out free))
{
free = 0;
}
HeapSegments.Add(new SegmentInfo
{
Size = segment.Length,
Reserved = segment.ReservedEnd - segment.Start,
Committed = segment.CommittedEnd - segment.Start,
IsLargeObjectHeap = segment.IsLarge,
FragmentationPercent = 100.0 * free / segment.Length
});
}
HeapFragmentationPercent = 100.0 * freeSpaceBySegment.Values.Sum(l => (long)l) / context.Heap.TotalHeapSize;
LargeObjectHeapFragmentationPercent = 100.0 * freeSpaceBySegment.Where(s => s.Key.IsLarge).Sum(l => (long)l.Value) / context.Heap.GetSizeByGen(3);
if (LargeObjectHeapFragmentationPercent > 20.0)
{
Recommendations.Add(new LargeObjectHeapFragmented {
FragmentationPercent = LargeObjectHeapFragmentationPercent
});
}
return(true);
}
private void RecommendDeadlockedThreads()
{
var visitedThreadIds = new HashSet <uint>();
foreach (var thread in Threads)
{
// We don't want to repeat the same deadlock multiple times
// for the same threads that are involved. It doesn't matter
// which thread we start from, we will end up with the same
// deadlock "picture".
if (visitedThreadIds.Contains(thread.OSThreadId))
{
continue;
}
if (HasCycle(thread, visitedThreadIds))
{
Recommendations.Add(new DeadlockedThreads {
StartingThreadOSId = thread.OSThreadId
});
}
}
}
// The finalizer thread stack can be obtained from the threads stack report.
public override bool Generate(CommandExecutionContext context)
{
if (context.TargetType == TargetType.DumpFileNoHeap)
{
return(false);
}
FinalizerThreadOSID = context.Runtime.Threads.SingleOrDefault(t => t.IsFinalizer)?.OSThreadId ?? 0;
var readyForFinalization = context.Runtime.EnumerateFinalizerQueueObjectAddresses().ToList();
MemoryBytesReachableFromFinalizationQueue = context.Heap.SizeReachableFromObjectSet(readyForFinalization);
ObjectsWaitingForFinalization.AddRange(
context.Heap.GroupTypesInObjectSetAndSortBySize(readyForFinalization));
ObjectsWithFinalizers.AddRange(context.Heap.GroupTypesInObjectSetAndSortBySize(
context.Heap.EnumerateFinalizableObjectAddresses()));
if (readyForFinalization.Count > 100)
{
Recommendations.Add(new FinalizationQueueTooBig
{
Count = (ulong)readyForFinalization.Count,
Size = MemoryBytesReachableFromFinalizationQueue
});
}
var numberOfObjectsWithFinalizers = ObjectsWithFinalizers.Sum(group => (long)group.Size);
if (numberOfObjectsWithFinalizers > 10000)
{
Recommendations.Add(new TooManyFinalizableObjects {
Count = (ulong)numberOfObjectsWithFinalizers
});
}
return(true);
}
private void AddModel(Recommendation recommendation, bool isRead)
{
var currentUser = User.Followings.Single(c => c.Id == recommendation.UserId);
Recommendations.Add(RecommendationViewModel.FromModel(recommendation, currentUser, settings.Font, isRead));
}
void recsWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
AnimeSeriesVM ser = e.Argument as AnimeSeriesVM;
System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Recommendations.Clear();
});
List <JMMServerBinary.Contract_AniDB_Anime_Similar> links = JMMServerVM.Instance.clientBinaryHTTP.GetSimilarAnimeLinks(ser.AniDB_ID,
JMMServerVM.Instance.CurrentUser.JMMUserID.Value);
List <AniDB_Anime_SimilarVM> tempList = new List <AniDB_Anime_SimilarVM>();
foreach (JMMServerBinary.Contract_AniDB_Anime_Similar link in links)
{
AniDB_Anime_SimilarVM sim = new AniDB_Anime_SimilarVM();
sim.Populate(link);
tempList.Add(sim);
}
List <SortPropOrFieldAndDirection> sortCriteria = new List <SortPropOrFieldAndDirection>();
sortCriteria.Add(new SortPropOrFieldAndDirection("ApprovalPercentage", true, SortType.eDoubleOrFloat));
tempList = Sorting.MultiSort <AniDB_Anime_SimilarVM>(tempList, sortCriteria);
foreach (AniDB_Anime_SimilarVM sim in tempList)
{
if (sim.AnimeInfoNotExists)
{
string result = JMMServerVM.Instance.clientBinaryHTTP.UpdateAnimeData(sim.SimilarAnimeID);
if (string.IsNullOrEmpty(result))
{
JMMServerBinary.Contract_AniDBAnime animeContract = JMMServerVM.Instance.clientBinaryHTTP.GetAnime(sim.SimilarAnimeID);
sim.PopulateAnime(animeContract);
}
}
System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Recommendations.Add(new RecommendationTile()
{
Details = "",
AnimeName = sim.DisplayName,
Picture = sim.PosterPath,
AnimeSeries = sim.AnimeSeries,
TileSize = "Large",
Height = 100,
Source = "AniDB",
AnimeID = sim.AnimeID,
URL = sim.AniDB_SiteURL,
SimilarAnimeID = sim.SimilarAnimeID,
HasSeries = sim.LocalSeriesExists
});
});
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
public override bool Generate(CommandExecutionContext context)
{
_title = Path.GetFileName(context.DumpFile);
switch (context.TargetType)
{
case TargetType.DumpFile:
DumpType = "Full memory dump with heap";
break;
case TargetType.DumpFileNoHeap:
DumpType = "Mini dump with no heap";
break;
default:
DumpType = "Unsupported dump file type";
break;
}
var target = context.NativeDbgEngTarget;
IDebugSystemObjects2 sysObjects = (IDebugSystemObjects2)target.DebuggerInterface;
IDebugControl2 control = (IDebugControl2)target.DebuggerInterface;
uint dummy;
StringBuilder exeName = new StringBuilder(2048);
if (HR.Succeeded(sysObjects.GetCurrentProcessExecutableName(exeName, exeName.Capacity, out dummy)))
{
ExecutableName = exeName.ToString();
}
uint uptime;
if (HR.Succeeded(sysObjects.GetCurrentProcessUpTime(out uptime)))
{
ProcessUpTimeInSeconds = uptime;
}
if (HR.Succeeded(control.GetCurrentSystemUpTime(out uptime)))
{
SystemUpTimeInSeconds = uptime;
}
uint time;
if (HR.Succeeded(control.GetCurrentTimeDate(out time)))
{
SessionTime = DateTimeOffset.FromUnixTimeSeconds(time);
}
uint num;
if (HR.Succeeded(control.GetNumberProcessors(out num)))
{
NumberOfProcessors = num;
}
uint platformId, major, minor, servicePackNumber;
StringBuilder servicePack = new StringBuilder(1048);
StringBuilder build = new StringBuilder(1048);
if (HR.Succeeded(control.GetSystemVersion(out platformId, out major, out minor, servicePack, servicePack.Capacity, out dummy, out servicePackNumber, build, build.Capacity, out dummy)))
{
WindowsBuildNumber = minor;
WindowsServicePack = servicePack.ToString();
WindowsServicePackNumber = servicePackNumber;
WindowsBuild = build.ToString();
}
ClrVersions.AddRange(context.Runtime.DataTarget.ClrVersions.Select(v => v.Version.ToString()));
if (context.Runtime.DataTarget.ClrVersions.Any(v => v.Version.Minor == 2))
{
Recommendations.Add(new CLRV2Detected());
}
return(true);
}
public override bool Generate(CommandExecutionContext context)
{
var target = context.NativeDbgEngTarget;
var lastEvent = target.GetLastEventInformation();
if (lastEvent == null)
{
return(false);
}
var stackTraces = new UnifiedStackTraces(target.DebuggerInterface, context);
var threadWithException = stackTraces.Threads.SingleOrDefault(t => t.OSThreadId == lastEvent.OSThreadId);
if (threadWithException == null)
{
return(false);
}
Exception = new ExceptionInfo
{
ExceptionCode = lastEvent.ExceptionRecord?.ExceptionCode ?? 0
};
if (Exception.ExceptionCode == 0)
{
return(false);
}
OSThreadId = threadWithException.OSThreadId;
ManagedThreadId = threadWithException.ManagedThread?.ManagedThreadId ?? 0;
// Note that we want the thread's stack from the exception context,
// and not from wherever it is right now.
Exception.StackFrames = stackTraces.GetStackTraceFromStoredEvent()
.Where(f => f.Type != UnifiedStackFrameType.Special)
.Select(f => f.DisplayString)
.ToList();
// Note that we might have an exception, but if it wasn't managed
// then the Thread.CurrentException field will be null.
var exception = threadWithException.ManagedThread?.CurrentException;
if (exception == null)
{
return(true);
}
Exception.ExceptionType = exception.Type.Name;
Exception.ExceptionMessage = exception.Message;
exception = exception.Inner;
var exceptionInfo = Exception;
while (exception != null)
{
exceptionInfo.InnerException = new ExceptionInfo();
exceptionInfo = exceptionInfo.InnerException;
exceptionInfo.ExceptionType = exception.Type.Name;
exceptionInfo.ExceptionMessage = exception.Message;
exceptionInfo.StackFrames = exception.StackTrace.Select(f => f.DisplayString).ToList();
exception = exception.Inner;
}
if (Exception != null)
{
Recommendations.Add(new UnhandledExceptionOccurred {
Exception = Exception
});
}
return(true);
}
