/// <summary>Read in static rating data from a TextReader</summary> /// <param name="reader">the <see cref="TextReader"/> to read from</param> /// <param name="size">the number of ratings in the file</param> /// <param name="user_mapping">mapping object for user IDs</param> /// <param name="item_mapping">mapping object for item IDs</param> /// <param name="rating_type">the data type to be used for storing the ratings</param> /// <returns>the rating data</returns> public static IRatings Read(TextReader reader, int size, IEntityMapping user_mapping, IEntityMapping item_mapping, RatingType rating_type) { IRatings ratings; if (rating_type == RatingType.BYTE) ratings = new StaticByteRatings(size); else if (rating_type == RatingType.FLOAT) ratings = new StaticFloatRatings(size); else ratings = new StaticRatings(size); var split_chars = new char[]{ '\t', ' ', ',' }; string line; while ( (line = reader.ReadLine()) != null ) { if (line.Length == 0) continue; string[] tokens = line.Split(split_chars); if (tokens.Length < 3) throw new IOException("Expected at least three columns: " + line); int user_id = user_mapping.ToInternalID(int.Parse(tokens[0])); int item_id = item_mapping.ToInternalID(int.Parse(tokens[1])); double rating = double.Parse(tokens[2], CultureInfo.InvariantCulture); ratings.Add(user_id, item_id, rating); } return ratings; }
public void WhenValidCodeParam_ThenSetProperties(RatingType type, string code) { var sut = new Rating(code); Assert.That(sut.Type, Is.EqualTo(type)); Assert.That(sut.Code, Is.EqualTo(code)); }
private List <Series> GetListOf(RatingType ratingType) { tlPanel.Controls.Clear(); Dictionary <int, Rating> ratings = dataAccess.GetAllRatings(currentUser.Id); currentUser.Ratings = ratings; if (ratings != null) { var filteredList = new List <int>(); switch (ratingType) { case RatingType.FAVORITES: filteredList = ratings.Where(x => x.Value.Favorite).Select(x => x.Value.Id_series).ToList(); break; case RatingType.MARKED: filteredList = ratings.Where(x => x.Value.Marked).Select(x => x.Value.Id_series).ToList(); break; case RatingType.SEEN: filteredList = ratings.Where(x => x.Value.Seen).Select(x => x.Value.Id_series).ToList(); break; case RatingType.ALL: filteredList = series.Select(x => x.Id_series).ToList(); break; } return(series.Where(x => filteredList.Contains(x.Id_series)).ToList()); } return(null); }
protected CASRLicenseBase(string szBaseFAR, string szTitle, RatingType rt, string szCategoryName) { Title = szTitle; BaseFAR = szBaseFAR; RatingSought = rt; CategoryRestriction = szCategoryName; }
public void AddRating(string userId, RatingType ratingType, Post post) { var like = _postFactory.CreateLike(post.Id, userId, ratingType); post.Likes.Add(like); post.Rank = (ratingType == RatingType.Positive) ? ++post.Rank : --post.Rank; }
public async Task <TvDbResponse <UserRatings[]> > GetRatingsAsync(RatingType type, CancellationToken cancellationToken) { var request = new ApiRequest("GET", $"/user/ratings/query?itemType={this.UrlHelpers.QuerifyEnum(type)}"); var response = await this.ApiClient.SendRequestAsync(request, cancellationToken).ConfigureAwait(false); return(this.Parser.Parse <TvDbResponse <UserRatings[]> >(response, ErrorMessages.Users.GetRatingsAsync)); }
//--------------------------------- Constructors ------------------------------------------------- public CarrierRoute(CarrierRouteRow pCarrierRouteRow) { carrierRouteRow = pCarrierRouteRow; CarrierAcctId = carrierRouteRow.Carrier_acct_id; //-- set name RouteRow _routeRow; using (var _db = new Rbr_Db()) { _routeRow = _db.RouteCollection.GetByPrimaryKey(carrierRouteRow.Route_id); } Name = _routeRow == null ? AppConstants.Unknown : _routeRow.Name; BaseRouteId = _routeRow == null ? carrierRouteRow.Route_id : _routeRow.Route_id; //-- set ratingtype CarrierAcctRow _carrierAcctRow; using (var _db = new Rbr_Db()) { _carrierAcctRow = _db.CarrierAcctCollection.GetByPrimaryKey(carrierAcctId); } if (_carrierAcctRow == null) { throw new Exception(string.Format("CarrierRoute.Ctor | CarrierAcctRow NOT FOUND, carrierAcctId:{0}", carrierAcctId)); } ratingType = _carrierAcctRow.RatingType; }
public RatingType Get(int id) { RatingType ratingType = TypeRepository.Get(id).Map <RatingType>(); ratingType.RateChoices = GetRateChoices(id); return(ratingType); }
public async Task RemoveRatingAsync(RatingType itemType, int itemId, CancellationToken cancellationToken) { var request = new ApiRequest("DELETE", $"/user/ratings/{this.UrlHelpers.QuerifyEnum(itemType)}/{itemId}"); var response = await this.ApiClient.SendRequestAsync(request, cancellationToken).ConfigureAwait(false); var data = this.Parser.Parse <TvDbResponse <UserRatings[]> >(response, ErrorMessages.Users.RemoveFromFavoritesAsync); }
protected void LoadAllRatingTypesCompletedHelper() { try { dispatcher.BeginInvoke (() => { if (Utility.FaultExist(ratingTypeService.Fault)) { return; } if (ratingTypeService.Models != null) { ratingTypeService.Models.Insert(0, new Infrastructure.MangoService.RatingType() { Name = "<< Select Rating Type >>" }); RatingTypes = new PagedCollectionView(ratingTypeService.Models); RatingTypes.MoveCurrentToFirst(); RatingTypes.CurrentChanged += (s, e) => { RatingType = RatingTypes.CurrentItem as RatingType; }; } }); } catch (Exception ex) { Utility.DisplayMessage(ex.Message); } }
private void button1_Click(object sender, EventArgs e) { RatingType type = RatingType.ALL; if (cb_favorit.Checked) { type = RatingType.FAVORITES; } else if (cb_gesehen.Checked) { type = RatingType.SEEN; } else if (cb_vermerkt.Checked) { type = RatingType.MARKED; } List <string> genres = new List <string>(); foreach (Control control in fp_genreList.Controls) { if (control.GetType() == typeof(CheckBox)) { CheckBox box = (CheckBox)control; if (box.Checked) { genres.Add(box.Text); } } } tlPanel.Controls.Clear(); LoadSeries(GetListOf(type, genres)); }
protected EASALAPL(RatingType rt, string szBaseFar, string szTitle) : base() { RatingSought = rt; BaseFAR = szBaseFar; Title = szTitle; FARLink = MilestoneProgress.EASA_PART_FCL_LINK; }
/// <summary>Read in static rating data from a file</summary> /// <param name="filename">the name of the file to read from</param> /// <param name="user_mapping">mapping object for user IDs</param> /// <param name="item_mapping">mapping object for item IDs</param> /// <param name="rating_type">the data type to be used for storing the ratings</param> /// <param name="ignore_first_line">if true, ignore the first line</param> /// <returns>the rating data</returns> public static IRatings Read( string filename, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null, RatingType rating_type = RatingType.FLOAT, bool ignore_first_line = false) { string binary_filename = filename + ".bin.StaticRatings"; if (FileSerializer.Should(user_mapping, item_mapping) && File.Exists(binary_filename)) return (IRatings) FileSerializer.Deserialize(binary_filename); int size = 0; using ( var reader = new StreamReader(filename) ) while (reader.ReadLine() != null) size++; if (ignore_first_line) size--; return Wrap.FormatException<IRatings>(filename, delegate() { using ( var reader = new StreamReader(filename) ) { var ratings = (StaticRatings) Read(reader, size, user_mapping, item_mapping, rating_type); if (FileSerializer.Should(user_mapping, item_mapping) && FileSerializer.CanWrite(binary_filename)) ratings.Serialize(binary_filename); return ratings; } }); }
/// <summary> /// gets rating of transfer between two points /// </summary> /// <param name="type">rating type</param> /// <param name="from">first point</param> /// <param name="to">second point</param> /// <returns>cost of transfer</returns> public float GetRating(RatingType type, Point from, Point to) { int rating = 1; switch (type) { case RatingType.Hiding: //rating /= (height / 10); //if (bDanger) // rating /= 10; //if (bPlayer) // rating /= 10; //if (bBlock) // rating = 999999; break; case RatingType.Explore: //rating += height / 10; break; case RatingType.Direct: break; case RatingType.Carefull: break; default: break; } //rating += 2; return(rating); }
public async Task <RatingsWithUserCount> GetRatings(RatingType type) { var userId = this.GetCurrentUserId(); var ratings = await _ratingService.GetRatings(userId, type); return(ratings); }
/// <summary>Read in static rating data from a TextReader</summary> /// <param name="reader">the <see cref="TextReader"/> to read from</param> /// <param name="size">the number of ratings in the file</param> /// <param name="user_mapping">mapping object for user IDs</param> /// <param name="item_mapping">mapping object for item IDs</param> /// <param name="rating_type">the data type to be used for storing the ratings</param> /// <param name="ignore_first_line">if true, ignore the first line</param> /// <returns>the rating data</returns> static public IRatings Read( TextReader reader, int size, IMapping user_mapping = null, IMapping item_mapping = null, RatingType rating_type = RatingType.FLOAT, bool ignore_first_line = false) { if (user_mapping == null) { user_mapping = new IdentityMapping(); } if (item_mapping == null) { item_mapping = new IdentityMapping(); } if (ignore_first_line) { reader.ReadLine(); } IRatings ratings; if (rating_type == RatingType.BYTE) { ratings = new StaticByteRatings(size); } else if (rating_type == RatingType.FLOAT) { ratings = new StaticRatings(size); } else { throw new FormatException(string.Format("Unknown rating type: {0}", rating_type)); } string line; while ((line = reader.ReadLine()) != null) { if (line.Length == 0) { continue; } string[] tokens = line.Split(Constants.SPLIT_CHARS); if (tokens.Length < 3) { throw new FormatException("Expected at least 3 columns: " + line); } int user_id = user_mapping.ToInternalID(tokens[0]); int item_id = item_mapping.ToInternalID(tokens[1]); float rating = float.Parse(tokens[2], CultureInfo.InvariantCulture); ratings.Add(user_id, item_id, rating); } ratings.InitScale(); return(ratings); }
internal void RemoveRating(RatingType type) { if (Ratings.ContainsKey(type)) { Ratings.Remove(type); RefreshViewModel(); } }
public StreamingContent(string name, ContentType content, RatingType rating, double duration, GenreType genre) { Name = name; TypeOfContent = content; TypeOfRating = rating; TypeOfGenre = genre; Duration = duration; }
protected ATPCanadaBase(string title, string category, string altcategory, string basefar, RatingType ratingtype) { Title = title; Category = category; AltCategory = altcategory; BaseFAR = basefar; RatingSought = ratingtype; }
protected CASRLicenseBase(string szBaseFAR, string szTitle, RatingType rt, string szCategoryName) { Title = szTitle; BaseFAR = szBaseFAR; RatingSought = rt; CategoryRestriction = szCategoryName; FARLink = "https://www.legislation.gov.au/Details/F2015C00762/Html/Volume_2"; }
protected CFIBase(string title, CategoryClass.CatClassID ccid, RatingType rt) { Title = title; requiredCatClassID = ccid; BaseFAR = "61.183"; RatingSought = rt; miPIC = new MilestoneItem(String.Format(CultureInfo.CurrentCulture, Resources.MilestoneProgress.CFITimeInCategoryClass, CFIMinTime, CategoryClass.CategoryClassFromID(ccid).CatClass), ResolvedFAR("(j)"), string.Empty, MilestoneItem.MilestoneType.Time, CFIMinTime); }
// ReSharper disable once InconsistentNaming public Task AddRatingAsync_Makes_The_Right_Request(RatingType itemType, int itemId, decimal rating) { return(CreateClient() .WithErrorMap(ErrorMessages.Users.RateAsync) .SetResultObject(new TvDbResponse <UserRatings[]>()) .WhenCallingAMethod((impl, token) => impl.AddRatingAsync(itemType, itemId, rating, token)) .ShouldRequest("PUT", $"/user/ratings/{this.UrlHelpers.QuerifyEnum(itemType)}/{itemId}/{rating}") .RunAsync()); }
protected IFR141Base(string szTitle, string szBaseFAR, RatingType ratingSought) { Init(szTitle, szBaseFAR, ratingSought); miIMCAircraftTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(a)(1)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, totalIMCTime); miIMCFSTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(b)(1)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, maxIMCFSTime); miIMCFTDTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(b)(2)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, maxIMCFTDTime); miIMCATDTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(b)(3)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, maxIMCATDTime); }
public Like CreateLike(int PostId, string UserId, RatingType rank) { var model = new Like() { PostId = PostId, UserID = UserId, RatingType = rank }; return(model); }
public static Videa.CuratedRatingNS.Data.DataServices.RatingType ToEntity(this RatingType source) { return(new Videa.CuratedRatingNS.Data.DataServices.RatingType { RatingTypeId = source.RatingTypeId, RatingTypeName = source.RatingTypeName, RatingTypeDescription = source.RatingTypeDescription }); }
// ReSharper disable once InconsistentNaming public Task GetRatingsAsync_Makes_The_Right_Request(RatingType type) { return(CreateClient() .WithErrorMap(ErrorMessages.Users.GetRatingsAsync) .SetResultObject(new TvDbResponse <UserRatings[]>()) .WhenCallingAMethod((impl, token) => impl.GetRatingsAsync(type, token)) .ShouldRequest("GET", $"/user/ratings/query?itemType={this.UrlHelpers.QuerifyEnum(type)}") .RunAsync()); }
public async Task <TVDBResponse <List <UserRatings> > > AddRatingAsync( RatingType itemType, int itemId, decimal rating, CancellationToken cancellationToken = default) { return(await PutJsonAsync <TVDBResponse <List <UserRatings> > >($"/user/ratings/{itemType.ToPascalCase()}/{itemId}/{rating}", cancellationToken) .ConfigureAwait(false)); }
protected CASRLicenseBase(string szBaseFAR, string szTitle, RatingType rt, string szCategoryName) { Title = szTitle; BaseFAR = szBaseFAR; RatingSought = rt; CategoryRestriction = szCategoryName; m_milestones = new Collection <MilestoneItem>(); }
public RatingType Update(RatingType ratingType) { TypeRepository.Update(ratingType.Map <DbRatingType>()); foreach (RateChoice choice in ratingType.RateChoices) { UpdateChoice(choice); } return(Get(ratingType.Id)); }
private List <Series> GetListOf(RatingType ratingType, List <string> genres) { tlPanel.Controls.Clear(); Dictionary <int, Rating> ratings = dataAccess.GetAllRatings(currentUser.Id); currentUser.Ratings = ratings; List <Series> resutlSeries = new List <Series>(); if (ratings != null) { var filteredList = new List <int>(); switch (ratingType) { case RatingType.FAVORITES: filteredList = ratings.Where(x => x.Value.Favorite).Select(x => x.Value.Id_series).ToList(); break; case RatingType.MARKED: filteredList = ratings.Where(x => x.Value.Marked).Select(x => x.Value.Id_series).ToList(); break; case RatingType.SEEN: filteredList = ratings.Where(x => x.Value.Seen).Select(x => x.Value.Id_series).ToList(); break; case RatingType.ALL: filteredList = series.Select(x => x.Id_series).ToList(); break; } List <Series> filteredSeries = series.Where(x => filteredList.Contains(x.Id_series)).ToList(); if (genres.Count > 0) { foreach (Series serie in filteredSeries) { int bananenBrot = 0; foreach (Genre genre in serie.Genres) { if (genres.Contains(genre.Description)) { bananenBrot++; } } if (bananenBrot == genres.Count) { resutlSeries.Add(serie); } } } else { resutlSeries = filteredSeries; } } return(resutlSeries); }
private ActionResult Rate(int?id, RatingType type) { using (var cx = new ViralContext()) { var existingRating = cx.Ratings.SingleOrDefault(r => r.User.Id == CurrentUserId && r.Comment.Id == id); if (existingRating != null) { existingRating.RatedTime = DateTime.UtcNow; existingRating.Type = type; cx.Entry(existingRating).State = EntityState.Modified; } else { var comment = cx.Comments .Where(p => p.Id == id) .Include(p => p.Ratings) .SingleOrDefault(); if (comment == null) { return(RedirectToAction("Index", "Home")); } var user = cx.Users .Where(u => u.Id == CurrentUserId) .Include(u => u.Ratings) .Single(); var rating = new Rating { RatedTime = DateTime.UtcNow, Type = type }; if (user.Ratings == null) { user.Ratings = new List <Rating>(); } user.Ratings.Add(rating); if (comment.Ratings == null) { comment.Ratings = new List <Rating>(); } comment.Ratings.Add(rating); cx.Entry(user).State = EntityState.Modified; cx.Entry(comment).State = EntityState.Modified; } cx.SaveChanges(); return(RedirectToAction("Index", "Home")); } }
protected IFR141Base(string szTitle, string szBaseFAR, RatingType ratingSought, int minXCDistance = 250) { MinXCDistance = minXCDistance; Init(szTitle, szBaseFAR, ratingSought, "https://www.law.cornell.edu/cfr/text/14/appendix-C_to_part_141"); miIMCAircraftTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(a)(1)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, totalIMCTime); miIMCFSTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(b)(1)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, maxIMCFSTime); miIMCFTDTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(b)(2)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, maxIMCFTDTime); miIMCATDTime = new MilestoneItem(Resources.MilestoneProgress.MinInstrumentTime141, ResolvedFAR("(b)(3)"), Resources.MilestoneProgress.Note141InstrumentReducedHours, MilestoneItem.MilestoneType.Time, maxIMCATDTime); }
/// <summary> /// This constructor is used when we just what non-violated named condition /// </summary> public Condition(string name) { if (name == null) { System.Diagnostics.Trace.WriteLine( Workshare.Reports.Properties.Resources.TRACE_NULL, "Condition Constructor 1" ); throw ( new ArgumentNullException( "name", Workshare.Reports.Properties.Resources.TRACE_NULL ) ); } m_name = name; m_rating = RatingType.None; m_fails = new FailureCollection(); }
/// <summary> /// Initializes a new instance of the <see cref="FeedbackItem"/> class. /// </summary> /// <param name="applicationId">The application id.</param> /// <param name="screenName">Name of the screen.</param> /// <param name="message">The message.</param> /// <param name="ratingType">Type of the rating.</param> /// <param name="sessionId">The session id.</param> /// <param name="version">The version.</param> public FeedbackItem(Guid applicationId, String screenName, String message, RatingType ratingType, Guid sessionId, String version) { this.ApplicationId = applicationId; this.Version = version; this.ScreenName = screenName; this.Message = message; this.Rating = ratingType; this.DateCreated = DateTime.Now; this.SessionId = sessionId; }
/// <summary>Read in static rating data from a file</summary> /// <param name="filename">the name of the file to read from, "-" if STDIN</param> /// <param name="user_mapping">mapping object for user IDs</param> /// <param name="item_mapping">mapping object for item IDs</param> /// <param name="rating_type">the data type to be used for storing the ratings</param> /// <returns>the rating data</returns> public static IRatings Read(string filename, IEntityMapping user_mapping, IEntityMapping item_mapping, RatingType rating_type) { int size = 0; using ( var reader = new StreamReader(filename) ) while (reader.ReadLine() != null) size++; using ( var reader = new StreamReader(filename) ) return Read(reader, size, user_mapping, item_mapping, rating_type); }
// http://stackoverflow.com/q/424366 /// <summary> /// Gets the link to avatar by gravatar. /// </summary> /// <param name="content">The content (email).</param> /// <param name="size">The size of avatar.</param> /// <param name="ratingType">Type of the rating.</param> /// <param name="defaultImage">The type of default image.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException">content</exception> /// <exception cref="System.ArgumentOutOfRangeException">size;The image size should be between 1 and 2048</exception> public static string Get(string content, int size = 80, RatingType ratingType = RatingType.PG, DefaultImage defaultImage = DefaultImage.MM) { if (content == null) throw new ArgumentNullException("content"); if (size < 1 | size > 2048) throw new ArgumentOutOfRangeException("size", "The image size should be between 1 and 2048"); return String.Format("{0}?gravatar_id={1}&s={2}&r={3}&d={4}", Url, MD5.GetHashString(content.ToLower()), size, ratingType.ToString("G"), defaultImage.ToString("G")).ToLower(); }
/// <summary>Read in static rating data from a TextReader</summary> /// <param name="reader">the <see cref="TextReader"/> to read from</param> /// <param name="size">the number of ratings in the file</param> /// <param name="user_mapping">mapping object for user IDs</param> /// <param name="item_mapping">mapping object for item IDs</param> /// <param name="rating_type">the data type to be used for storing the ratings</param> /// <param name="test_rating_format">whether there is a rating column in each line or not</param> /// <param name="ignore_first_line">if true, ignore the first line</param> /// <returns>the rating data</returns> public static IRatings Read( TextReader reader, int size, IMapping user_mapping = null, IMapping item_mapping = null, RatingType rating_type = RatingType.FLOAT, TestRatingFileFormat test_rating_format = TestRatingFileFormat.WITH_RATINGS, bool ignore_first_line = false) { if (user_mapping == null) user_mapping = new IdentityMapping(); if (item_mapping == null) item_mapping = new IdentityMapping(); if (ignore_first_line) reader.ReadLine(); IRatings ratings; if (rating_type == RatingType.BYTE) ratings = new StaticByteRatings(size); else if (rating_type == RatingType.FLOAT) ratings = new StaticRatings(size); else throw new FormatException(string.Format("Unknown rating type: {0}", rating_type)); string line; while ((line = reader.ReadLine()) != null) { if (line.Length == 0) continue; string[] tokens = line.Split(Constants.SPLIT_CHARS); if (test_rating_format == TestRatingFileFormat.WITH_RATINGS && tokens.Length < 3) throw new FormatException("Expected at least 3 columns: " + line); if (test_rating_format == TestRatingFileFormat.WITHOUT_RATINGS && tokens.Length < 2) throw new FormatException("Expected at least 2 columns: " + line); int user_id = user_mapping.ToInternalID(tokens[0]); int item_id = item_mapping.ToInternalID(tokens[1]); float rating = test_rating_format == TestRatingFileFormat.WITH_RATINGS ? float.Parse(tokens[2], CultureInfo.InvariantCulture) : 0; ratings.Add(user_id, item_id, rating); } ratings.InitScale(); return ratings; }
private ExperienceRating(Guid id, ExperienceArea experienceArea, RatingType type, int rating, IClock clock) { Id = id; ExperienceArea = experienceArea; Type = type; if (rating > 5 || rating < 0) { throw new InvalidDataException("A rating must be between 0 and 5"); } Status = type == RatingType.Peer ? RatingStatus.Submitted : RatingStatus.Approved; if (type == RatingType.Self) { SelfRating = rating; PeerRating = 0; TimeOfSelfRating = clock.UtcNow; } else { PeerRating = rating; SelfRating = 0; TimeOfPeerRating = clock.UtcNow; } }
/// <summary> /// グループ情報を更新します。 /// </summary> /// <param name="gid"></param> /// <param name="groupname"></param> /// <param name="keyword"></param> /// <param name="groupRating"></param> public void UpdateGroup(long gid, string groupname, string keyword, RatingType groupRating) { GroupId = gid; GroupName = groupname; GroupKeyword = keyword; Rating = groupRating; // グループ名を使用したタイトルに変更する。 MovieTitle = MovieTitle.Replace(keyword, groupname); }
public void ModifyRating(GroupItem group, RatingType rating) { using (var tran = _databaseAccessor.BeginTransaction()) { var ids = _databaseAccessor.SelectIdFromGid(group.Gid); foreach (var id in ids) { _databaseAccessor.UpdateLibraryRating(id, rating); } tran.Commit(); } group.ModifyIsFavorite(rating == RatingType.Favorite); }
public void ModifyRating(RatingType newRating) { Rating = newRating; }
static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Handlers.UnhandledExceptionHandler); Console.CancelKeyPress += new ConsoleCancelEventHandler(AbortHandler); // recommender arguments string method = null; string recommender_options = string.Empty; // help/version bool show_help = false; bool show_version = false; // arguments for iteration search int max_iter = 100; string measure = "RMSE"; double epsilon = 0; double cutoff = double.MaxValue; // other arguments bool search_hp = false; int random_seed = -1; string prediction_line = "{0}\t{1}\t{2}"; string prediction_header = null; var p = new OptionSet() { // string-valued options { "training-file=", v => training_file = v }, { "test-file=", v => test_file = v }, { "recommender=", v => method = v }, { "recommender-options=", v => recommender_options += " " + v }, { "data-dir=", v => data_dir = v }, { "user-attributes=", v => user_attributes_file = v }, { "item-attributes=", v => item_attributes_file = v }, { "user-relations=", v => user_relations_file = v }, { "item-relations=", v => item_relations_file = v }, { "save-model=", v => save_model_file = v }, { "load-model=", v => load_model_file = v }, { "save-user-mapping=", v => save_user_mapping_file = v }, { "save-item-mapping=", v => save_item_mapping_file = v }, { "load-user-mapping=", v => load_user_mapping_file = v }, { "load-item-mapping=", v => load_item_mapping_file = v }, { "prediction-file=", v => prediction_file = v }, { "prediction-line=", v => prediction_line = v }, { "prediction-header=", v => prediction_header = v }, { "chronological-split=", v => chronological_split = v }, { "measure=", v => measure = v }, // integer-valued options { "find-iter=", (int v) => find_iter = v }, { "max-iter=", (int v) => max_iter = v }, { "random-seed=", (int v) => random_seed = v }, { "cross-validation=", (uint v) => cross_validation = v }, // double-valued options { "epsilon=", (double v) => epsilon = v }, { "cutoff=", (double v) => cutoff = v }, { "test-ratio=", (double v) => test_ratio = v }, // enum options { "rating-type=", (RatingType v) => rating_type = v }, { "file-format=", (RatingFileFormat v) => file_format = v }, // boolean options { "compute-fit", v => compute_fit = v != null }, { "online-evaluation", v => online_eval = v != null }, { "show-fold-results", v => show_fold_results = v != null }, { "search-hp", v => search_hp = v != null }, { "no-id-mapping", v => no_id_mapping = v != null }, { "help", v => show_help = v != null }, { "version", v => show_version = v != null }, }; IList<string> extra_args = p.Parse(args); // ... some more command line parameter actions ... bool no_eval = true; if (test_ratio > 0 || test_file != null || chronological_split != null) no_eval = false; if (show_version) ShowVersion(); if (show_help) Usage(0); if (random_seed != -1) MyMediaLite.Util.Random.Seed = random_seed; // set up recommender if (load_model_file != null) recommender = (RatingPredictor) Model.Load(load_model_file); else if (method != null) recommender = Recommender.CreateRatingPredictor(method); else recommender = Recommender.CreateRatingPredictor("BiasedMatrixFactorization"); // in case something went wrong ... if (recommender == null && method != null) Usage(string.Format("Unknown rating prediction method: '{0}'", method)); if (recommender == null && load_model_file != null) Abort(string.Format("Could not load model from file {0}.", load_model_file)); CheckParameters(extra_args); recommender.Configure(recommender_options, (string m) => { Console.Error.WriteLine(m); Environment.Exit(-1); }); // ID mapping objects if (file_format == RatingFileFormat.KDDCUP_2011 || no_id_mapping) { user_mapping = new IdentityMapping(); item_mapping = new IdentityMapping(); } if (load_user_mapping_file != null) user_mapping = EntityMappingExtensions.LoadMapping(load_user_mapping_file); if (load_item_mapping_file != null) item_mapping = EntityMappingExtensions.LoadMapping(load_item_mapping_file); // load all the data LoadData(!online_eval); // if requested, save ID mappings if (save_user_mapping_file != null) user_mapping.SaveMapping(save_user_mapping_file); if (save_item_mapping_file != null) item_mapping.SaveMapping(save_item_mapping_file); Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "ratings range: [{0}, {1}]", recommender.MinRating, recommender.MaxRating)); if (test_ratio > 0) { var split = new RatingsSimpleSplit(training_data, test_ratio); recommender.Ratings = training_data = split.Train[0]; test_data = split.Test[0]; Console.Error.WriteLine(string.Format( CultureInfo.InvariantCulture, "test ratio {0}", test_ratio)); } if (chronological_split != null) { var split = chronological_split_ratio != -1 ? new RatingsChronologicalSplit((ITimedRatings) training_data, chronological_split_ratio) : new RatingsChronologicalSplit((ITimedRatings) training_data, chronological_split_time); recommender.Ratings = training_data = split.Train[0]; test_data = split.Test[0]; if (test_ratio != -1) Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "test ratio (chronological) {0}", chronological_split_ratio)); else Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "split time {0}", chronological_split_time)); } Console.Write(training_data.Statistics(test_data, user_attributes, item_attributes)); if (find_iter != 0) { if ( !(recommender is IIterativeModel) ) Abort("Only iterative recommenders (interface IIterativeModel) support --find-iter=N."); Console.WriteLine(recommender.ToString()); if (cross_validation > 1) { recommender.DoIterativeCrossValidation(cross_validation, max_iter, find_iter); } else { var iterative_recommender = (IIterativeModel) recommender; var eval_stats = new List<double>(); if (load_model_file == null) recommender.Train(); if (compute_fit) Console.WriteLine("fit {0} iteration {1}", recommender.Evaluate(training_data), iterative_recommender.NumIter); Console.WriteLine("{0} iteration {1}", recommender.Evaluate(test_data), iterative_recommender.NumIter); for (int it = (int) iterative_recommender.NumIter + 1; it <= max_iter; it++) { TimeSpan time = Wrap.MeasureTime(delegate() { iterative_recommender.Iterate(); }); training_time_stats.Add(time.TotalSeconds); if (it % find_iter == 0) { if (compute_fit) { time = Wrap.MeasureTime(delegate() { Console.WriteLine("fit {0} iteration {1}", recommender.Evaluate(training_data), it); }); fit_time_stats.Add(time.TotalSeconds); } RatingPredictionEvaluationResults results = null; time = Wrap.MeasureTime(delegate() { results = recommender.Evaluate(test_data); }); eval_time_stats.Add(time.TotalSeconds); eval_stats.Add(results[measure]); Console.WriteLine("{0} iteration {1}", results, it); Model.Save(recommender, save_model_file, it); if (prediction_file != null) recommender.WritePredictions(test_data, prediction_file + "-it-" + it, user_mapping, item_mapping, prediction_line, prediction_header); if (epsilon > 0.0 && results[measure] - eval_stats.Min() > epsilon) { Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} >> {1}", results["RMSE"], eval_stats.Min())); Console.Error.WriteLine("Reached convergence on training/validation data after {0} iterations.", it); break; } if (results[measure] > cutoff) { Console.Error.WriteLine("Reached cutoff after {0} iterations.", it); break; } } } // for } } else { TimeSpan seconds; Console.Write(recommender + " "); if (load_model_file == null) { if (cross_validation > 1) { Console.WriteLine(); var results = recommender.DoCrossValidation(cross_validation, compute_fit, show_fold_results); Console.Write(results); no_eval = true; } else { if (search_hp) { double result = NelderMead.FindMinimum("RMSE", recommender); Console.Error.WriteLine("estimated quality (on split) {0}", result.ToString(CultureInfo.InvariantCulture)); } seconds = Wrap.MeasureTime( delegate() { recommender.Train(); } ); Console.Write(" training_time " + seconds + " "); } } if (!no_eval) { if (online_eval) seconds = Wrap.MeasureTime(delegate() { Console.Write(recommender.EvaluateOnline(test_data)); }); else seconds = Wrap.MeasureTime(delegate() { Console.Write(recommender.Evaluate(test_data)); }); Console.Write(" testing_time " + seconds); if (compute_fit) { Console.Write("\nfit "); seconds = Wrap.MeasureTime(delegate() { Console.Write(recommender.Evaluate(training_data)); }); Console.Write(" fit_time " + seconds); } if (prediction_file != null) { Console.WriteLine(); seconds = Wrap.MeasureTime(delegate() { recommender.WritePredictions(test_data, prediction_file, user_mapping, item_mapping, prediction_line, prediction_header); }); Console.Error.Write("prediction_time " + seconds); } } Console.WriteLine(); } Model.Save(recommender, save_model_file); DisplayStats(); }
/// <summary> /// This constructor will assign the item /// </summary> /// <param name="item">The message added</param> public ScanAuditEventArgs(string text, RatingType rating) { m_text = text; m_type = rating; }
public static ExperienceRating Create(Guid id, ExperienceArea experienceArea, RatingType type, int rating, IClock clock) { return new ExperienceRating(id, experienceArea, type, rating, clock); }
static public bool SubmitRating(RatingType type, string itemId, int rating) { string account = DBOption.GetOptions(DBOption.cOnlineUserID); if (String.IsNullOrEmpty(account)) { string[] lines = new string[] { Translation.TVDB_INFO_ACCOUNTID_1, Translation.TVDB_INFO_ACCOUNTID_2 }; //TVSeriesPlugin.ShowDialogOk(Translation.TVDB_INFO_TITLE, lines); //trakt.tv also listens to this, also can store ratings locally. MPTVSeriesLog.Write("Cannot submit rating to thetvdb.com, this requires your Account Identifier to be set."); return false; } if (itemId == "0" || rating < 0 || rating > 10) { MPTVSeriesLog.Write("Cannot submit rating, invalid values...this is most likely a programming error"); return false; } if (!DBOnlineMirror.IsMirrorsAvailable) { // Server maybe available now. DBOnlineMirror.Init(); if (!DBOnlineMirror.IsMirrorsAvailable) { GUIDialogOK dlgOK = (GUIDialogOK)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_OK); dlgOK.SetHeading(Translation.TVDB_ERROR_TITLE); if (!TVSeriesPlugin.IsNetworkAvailable) { string[] lines = new string[] { Translation.NETWORK_ERROR_UNAVAILABLE_1, Translation.NETWORK_ERROR_UNAVAILABLE_2 }; TVSeriesPlugin.ShowDialogOk(Translation.TVDB_ERROR_TITLE, lines); } else { string[] lines = new string[] { Translation.TVDB_ERROR_UNAVAILABLE_1, Translation.TVDB_ERROR_UNAVAILABLE_2 }; TVSeriesPlugin.ShowDialogOk(Translation.TVDB_ERROR_TITLE, lines); } MPTVSeriesLog.Write("Cannot submit rating, the online database is unavailable"); return false; } } // ok we're good MPTVSeriesLog.Write(string.Format("Submitting Rating of {2} for {0} {1}", type.ToString(), itemId, rating), MPTVSeriesLog.LogLevel.Debug); Generic(string.Format(apiURIs.SubmitRating, account, type.ToString(), itemId, rating), true, false, Format.NoExtension); return true; }
protected static void SetItemColour( ListViewItem item, bool isExternal, RatingType rating ) { if (isExternal) { // Now work out the colour of the item //item.UseItemStyleForSubItems = true; // Important note - Make sure that the colours are set after assigning // sub items or else the sub items will overwrite the settings!!! item.BackColor = Settings.ExternalEmailColour.Background; item.ForeColor = Settings.ExternalEmailColour.Foreground; } // Due the list view being a real pain in the axxx we have to do this again. if (rating == RatingType.High) { Font newFt = new Font(item.Font.FontFamily, item.Font.Size, FontStyle.Regular); item.Font = newFt; item.BackColor = Settings.HighColour.Background; item.ForeColor = Settings.HighColour.Foreground; } //Just make sure the entire line is coloured if high if (View.Columns[0].Name == "Rating") { switch (rating) { case RatingType.High: item.BackColor = Settings.HighColour.Background; item.ForeColor = Settings.HighColour.Foreground; break; case RatingType.Medium: item.BackColor = Settings.MediumColour.Background; item.ForeColor = Settings.MediumColour.Foreground; break; case RatingType.Low: item.BackColor = Settings.LowColour.Background; item.ForeColor = Settings.LowColour.Foreground; break; } } }
static void Main(string[] args) { Assembly assembly = Assembly.GetExecutingAssembly(); Assembly.LoadFile(Path.GetDirectoryName(assembly.Location) + Path.DirectorySeparatorChar + "MyMediaLiteExperimental.dll"); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Handlers.UnhandledExceptionHandler); Console.CancelKeyPress += new ConsoleCancelEventHandler(AbortHandler); // recommender arguments string method = "BiasedMatrixFactorization"; string recommender_options = string.Empty; // help/version bool show_help = false; bool show_version = false; // arguments for iteration search int find_iter = 0; int max_iter = 500; double epsilon = 0; double rmse_cutoff = double.MaxValue; double mae_cutoff = double.MaxValue; // data arguments string data_dir = string.Empty; string user_attributes_file = string.Empty; string item_attributes_file = string.Empty; string user_relations_file = string.Empty; string item_relations_file = string.Empty; // other arguments bool online_eval = false; bool search_hp = false; string save_model_file = string.Empty; string load_model_file = string.Empty; int random_seed = -1; string prediction_file = string.Empty; string prediction_line = "{0}\t{1}\t{2}"; int cross_validation = 0; double split_ratio = 0; var p = new OptionSet() { // string-valued options { "training-file=", v => training_file = v }, { "test-file=", v => test_file = v }, { "recommender=", v => method = v }, { "recommender-options=", v => recommender_options += " " + v }, { "data-dir=", v => data_dir = v }, { "user-attributes=", v => user_attributes_file = v }, { "item-attributes=", v => item_attributes_file = v }, { "user-relations=", v => user_relations_file = v }, { "item-relations=", v => item_relations_file = v }, { "save-model=", v => save_model_file = v }, { "load-model=", v => load_model_file = v }, { "prediction-file=", v => prediction_file = v }, { "prediction-line=", v => prediction_line = v }, // integer-valued options { "find-iter=", (int v) => find_iter = v }, { "max-iter=", (int v) => max_iter = v }, { "random-seed=", (int v) => random_seed = v }, { "cross-validation=", (int v) => cross_validation = v }, // double-valued options { "epsilon=", (double v) => epsilon = v }, { "rmse-cutoff=", (double v) => rmse_cutoff = v }, { "mae-cutoff=", (double v) => mae_cutoff = v }, { "split-ratio=", (double v) => split_ratio = v }, // enum options { "rating-type=", (RatingType v) => rating_type = v }, { "file-format=", (RatingFileFormat v) => file_format = v }, // boolean options { "compute-fit", v => compute_fit = v != null }, { "online-evaluation", v => online_eval = v != null }, { "search-hp", v => search_hp = v != null }, { "help", v => show_help = v != null }, { "version", v => show_version = v != null }, }; IList<string> extra_args = p.Parse(args); // TODO make sure interaction of --find-iter and --cross-validation works properly bool no_eval = test_file == null; if (show_version) ShowVersion(); if (show_help) Usage(0); if (extra_args.Count > 0) Usage("Did not understand " + extra_args[0]); if (training_file == null) Usage("Parameter --training-file=FILE is missing."); if (cross_validation != 0 && split_ratio != 0) Usage("--cross-validation=K and --split-ratio=NUM are mutually exclusive."); if (random_seed != -1) MyMediaLite.Util.Random.InitInstance(random_seed); recommender = Recommender.CreateRatingPredictor(method); if (recommender == null) Usage(string.Format("Unknown method: '{0}'", method)); Recommender.Configure(recommender, recommender_options, Usage); // ID mapping objects if (file_format == RatingFileFormat.KDDCUP_2011) { user_mapping = new IdentityMapping(); item_mapping = new IdentityMapping(); } // load all the data LoadData(data_dir, user_attributes_file, item_attributes_file, user_relations_file, item_relations_file, !online_eval); Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "ratings range: [{0}, {1}]", recommender.MinRating, recommender.MaxRating)); if (split_ratio > 0) { var split = new RatingsSimpleSplit(training_data, split_ratio); recommender.Ratings = split.Train[0]; training_data = split.Train[0]; test_data = split.Test[0]; } Utils.DisplayDataStats(training_data, test_data, recommender); if (find_iter != 0) { if ( !(recommender is IIterativeModel) ) Usage("Only iterative recommenders support find_iter."); var iterative_recommender = (IIterativeModel) recommender; Console.WriteLine(recommender.ToString() + " "); if (load_model_file == string.Empty) recommender.Train(); else Recommender.LoadModel(iterative_recommender, load_model_file); if (compute_fit) Console.Write(string.Format(CultureInfo.InvariantCulture, "fit {0,0:0.#####} ", iterative_recommender.ComputeFit())); MyMediaLite.Eval.Ratings.DisplayResults(MyMediaLite.Eval.Ratings.Evaluate(recommender, test_data)); Console.WriteLine(" iteration " + iterative_recommender.NumIter); for (int i = (int) iterative_recommender.NumIter + 1; i <= max_iter; i++) { TimeSpan time = Utils.MeasureTime(delegate() { iterative_recommender.Iterate(); }); training_time_stats.Add(time.TotalSeconds); if (i % find_iter == 0) { if (compute_fit) { double fit = 0; time = Utils.MeasureTime(delegate() { fit = iterative_recommender.ComputeFit(); }); fit_time_stats.Add(time.TotalSeconds); Console.Write(string.Format(CultureInfo.InvariantCulture, "fit {0,0:0.#####} ", fit)); } Dictionary<string, double> results = null; time = Utils.MeasureTime(delegate() { results = MyMediaLite.Eval.Ratings.Evaluate(recommender, test_data); }); eval_time_stats.Add(time.TotalSeconds); MyMediaLite.Eval.Ratings.DisplayResults(results); rmse_eval_stats.Add(results["RMSE"]); Console.WriteLine(" iteration " + i); Recommender.SaveModel(recommender, save_model_file, i); if (prediction_file != string.Empty) Prediction.WritePredictions(recommender, test_data, user_mapping, item_mapping, prediction_line, prediction_file + "-it-" + i); if (epsilon > 0.0 && results["RMSE"] - rmse_eval_stats.Min() > epsilon) { Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} >> {1}", results["RMSE"], rmse_eval_stats.Min())); Console.Error.WriteLine("Reached convergence on training/validation data after {0} iterations.", i); break; } if (results["RMSE"] > rmse_cutoff || results["MAE"] > mae_cutoff) { Console.Error.WriteLine("Reached cutoff after {0} iterations.", i); break; } } } // for DisplayStats(); } else { TimeSpan seconds; if (load_model_file == string.Empty) { if (cross_validation > 0) { Console.Write(recommender.ToString()); Console.WriteLine(); var split = new RatingCrossValidationSplit(training_data, cross_validation); var results = MyMediaLite.Eval.Ratings.EvaluateOnSplit(recommender, split); // TODO if (search_hp) MyMediaLite.Eval.Ratings.DisplayResults(results); no_eval = true; recommender.Ratings = training_data; } else { if (search_hp) { // TODO --search-hp-criterion=RMSE double result = NelderMead.FindMinimum("RMSE", recommender); Console.Error.WriteLine("estimated quality (on split) {0}", result.ToString(CultureInfo.InvariantCulture)); // TODO give out hp search time } Console.Write(recommender.ToString()); seconds = Utils.MeasureTime( delegate() { recommender.Train(); } ); Console.Write(" training_time " + seconds + " "); } } else { Recommender.LoadModel(recommender, load_model_file); Console.Write(recommender.ToString() + " "); } if (!no_eval) { if (online_eval) // TODO support also for prediction outputs (to allow external evaluation) seconds = Utils.MeasureTime(delegate() { MyMediaLite.Eval.Ratings.DisplayResults(MyMediaLite.Eval.Ratings.EvaluateOnline(recommender, test_data)); }); else seconds = Utils.MeasureTime(delegate() { MyMediaLite.Eval.Ratings.DisplayResults(MyMediaLite.Eval.Ratings.Evaluate(recommender, test_data)); }); Console.Write(" testing_time " + seconds); } if (compute_fit) { Console.Write("fit "); seconds = Utils.MeasureTime(delegate() { MyMediaLite.Eval.Ratings.DisplayResults(MyMediaLite.Eval.Ratings.Evaluate(recommender, training_data)); }); Console.Write(string.Format(CultureInfo.InvariantCulture, " fit_time {0,0:0.#####} ", seconds)); } if (prediction_file != string.Empty) { seconds = Utils.MeasureTime(delegate() { Console.WriteLine(); Prediction.WritePredictions(recommender, test_data, user_mapping, item_mapping, prediction_line, prediction_file); }); Console.Error.Write("predicting_time " + seconds); } Console.WriteLine(); Console.Error.WriteLine("memory {0}", Memory.Usage); } Recommender.SaveModel(recommender, save_model_file); }
protected static void SetSubItemColour(ListViewItem item, bool isExternal, ListViewItem.ListViewSubItem subItem, RatingType rating) { item.UseItemStyleForSubItems = false; if (isExternal) { // Now work out the colour of the item //item.UseItemStyleForSubItems = true; // Important note - Make sure that the colours are set after assigning // sub items or else the sub items will overwrite the settings!!! subItem.BackColor = Settings.ExternalEmailColour.Background; subItem.ForeColor = Settings.ExternalEmailColour.Foreground; } if (rating == RatingType.High) { Font newFt = new Font(subItem.Font.FontFamily, subItem.Font.Size, FontStyle.Regular); subItem.Font = newFt; subItem.BackColor = Settings.HighColour.Background; subItem.ForeColor = Settings.HighColour.Foreground; } if (subItem.Name == "Rating") { switch (rating) { case RatingType.High: subItem.BackColor = Settings.HighColour.Background; subItem.ForeColor = Settings.HighColour.Foreground; break; case RatingType.Medium: subItem.BackColor = Settings.MediumColour.Background; subItem.ForeColor = Settings.MediumColour.Foreground; break; case RatingType.Low: subItem.BackColor = Settings.LowColour.Background; subItem.ForeColor = Settings.LowColour.Foreground; break; } } }
/// <summary> /// Logs the feedback. /// </summary> /// <param name="screenName">Name of the screen.</param> /// <param name="ratingType">Type of the rating.</param> /// <param name="comment">The comment.</param> public void LogFeedback(string screenName, RatingType ratingType, string comment) { try { FeedbackItem feedbackItem = new FeedbackItem(this.applicationId, screenName, comment, ratingType, this.sessionId, this.applicationVersion); this.iStorageDal.Save(feedbackItem); this.setItemsWaitingToBeUploaded(); if (this.uploadType == UploadType.WhileUsingAsync) { this.uploadIntelligent(); } } catch (ExceptionDatabaseLayer ex) { this.logSystemError(ex); throw ex; } }
/// <summary> /// Creates the image tag. /// </summary> /// <param name="email">The email address.</param> /// <param name="size">The size in pixels (the height & width, as the image is square)</param> /// <param name="maxAllowedRating">The max allowed rating.</param> /// <param name="defaultImage">The default image, or keyword.</param> /// <param name="outputGravatarSiteLink">If set to <c>true</c> wrap image tag in anchor tag..</param> /// <param name="linkTitle">The title for the Gravatar site link..</param> /// <returns>string of HTML.</returns> /// <remarks>For a more detailed description of the parameters, <see cref="GravatarViewComponent"/></remarks> public string CreateImageTag(string email, int size, RatingType maxAllowedRating, string defaultImage, bool outputGravatarSiteLink, string linkTitle) { return GravatarHelper.CreateImageTag(email, size, defaultImage, maxAllowedRating, outputGravatarSiteLink, linkTitle); }
private void DoAutoConfiguration() { if (disable) { return; } SiteUser currentUser = SiteUtils.GetCurrentSiteUser(); if (currentUser == null) { disable = true; return; } SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings(); if (siteSettings == null) { disable = true; return; } switch (siteSettings.AvatarSystem) { case "gravatar": useGravatar = true; disable = false; break; case "internal": useGravatar = false; disable = false; break; case "none": default: useGravatar = false; disable = true; break; } siteId = siteSettings.SiteId; _maxAllowedRating = SiteUtils.GetMaxAllowedGravatarRating(); userId = currentUser.UserId; avatarFile = currentUser.AvatarUrl; Email = currentUser.Email; if (disableUseLinkWithAutoConfigure) { UseLink = false; } }
/// <summary> /// This constructor will assign the item /// </summary> /// <param name="item">The message added</param> public ScanAuditEventArgs( string text ) { m_text = text; m_type = RatingType.None; }
public virtual RatingType[] GetRatingType(long fbUserId, long[] songIds) { var queriedRatings = Ratings.Where(rating => songIds.Contains(rating.Song.Id)).ToArray(); /* in case user didn't vote for all songs, we need to have the * array in the size of the original given array and fill in values * for those songs that the user has voted for */ var ratingType = new RatingType[songIds.Length]; for (int index = 0; index < songIds.Length; index++) { /* only fill in the voting in the index of the songs the user * really did vote for */ var foundSongStatisicts = queriedRatings .Where(rating => rating.Song.Id == songIds[index]) .FirstOrDefault(); if (foundSongStatisicts != null) { ratingType[index] = foundSongStatisicts.GetCurrentUserRating(fbUserId); } } return ratingType; }
/// <summary> /// This is the default constructor /// </summary> public DigitalCounter() { InitializeComponent(); // Initialise the internal members m_numDigits = 5; m_overflow = true; m_digits = new ImageList(); m_digits.ImageSize = new Size(15, 20); m_numbers = new int[m_numDigits]; m_rating = RatingType.Medium; this.Size = new Size(48, 14); // Bitmap // Initialise the bitmap stuff GetNumbers(); ShowDigits(); SetDigits(); Invalidate(); }
/// <summary> /// This method will workout the rating type /// </summary> /// <param name="rating"></param> /// <returns></returns> private void WorkoutType( string rating ) { if (string.Compare( rating, "high", true, System.Threading.Thread.CurrentThread.CurrentCulture ) == 0) m_rating = RatingType.High; else if (string.Compare( rating, "medium", true, System.Threading.Thread.CurrentThread.CurrentCulture ) == 0) m_rating = RatingType.Medium; else if (string.Compare( rating, "low", true, System.Threading.Thread.CurrentThread.CurrentCulture ) == 0) m_rating = RatingType.Low; else m_rating = RatingType.None; System.Diagnostics.Trace.WriteLine( "Risk Rating Type is " + m_rating, "Condition.WorkoutType" ); }
/// <summary> /// Creates a Gravatar image tag. /// </summary> /// <param name="email">The email address.</param> /// <param name="size">The size in pixels (the height & width, as the image is square)</param> /// <param name="defaultImage">The default image, or keyword.</param> /// <param name="maxAllowedRating">The max allowed rating.</param> /// <param name="outputGravatarSiteLink">If set to <c>true</c> wrap image tag in anchor tag..</param> /// <param name="linkTitle">The title for the Gravatar site link..</param> /// <returns>string of HTML.</returns> /// <remarks><para> /// This is a static method, so that it can be called from a controller without having to /// create an instance of GravatarHelper. </para> /// <para>The parameters here are in a slightly different order from the instance methods, to prevent ambigity. /// </para> /// For a more detailed description of the parameters, <see cref="GravatarViewComponent"/></remarks> /// static public string CreateImageTag(string email, int size, string defaultImage, RatingType maxAllowedRating, bool outputGravatarSiteLink, string linkTitle) { if (string.IsNullOrEmpty(email)) throw new ArgumentException("Email address must be specified", "email"); if (size < 1 || size > 512) size = 80; // build up image url, including MD5 hash for supplied email: MD5CryptoServiceProvider md5Hasher = new MD5CryptoServiceProvider(); byte[] hashedBytes = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(email.ToLower())); StringBuilder sb = new StringBuilder(hashedBytes.Length * 2); foreach(byte b in hashedBytes) { sb.AppendFormat("{0:x2}", b); } string format = ""; if (string.IsNullOrEmpty(defaultImage)) { if (outputGravatarSiteLink) format = @"<a href=""http://www.gravatar.com"" title=""{4}""><img src=""http://www.gravatar.com/avatar/{0}.jpg?rating={1}&size={2}"" height=""{2}"" width=""{2}"" alt=""{4}"" /></a>"; else format = @"<img src=""http://www.gravatar.com/avatar/{0}.jpg?rating={1}&size={2}"" height=""{2}"" width=""{2}"" alt=""Gravatar"" />"; } else { if (outputGravatarSiteLink) format = @"<a href=""http://www.gravatar.com"" title=""{4}""><img src=""http://www.gravatar.com/avatar/{0}.jpg?rating={1}&size={2}&default={3}"" height=""{2}"" width=""{2}"" alt=""{4}"" /></a>"; else format = @"<img src=""http://www.gravatar.com/avatar/{0}.jpg?rating={1}&size={2}&default={3}"" height=""{2}"" width=""{2}"" alt=""Gravatar"" />"; } return string.Format(format, sb, maxAllowedRating, size, HttpUtility.UrlEncode(defaultImage), HttpUtility.HtmlEncode(linkTitle)); }
public static bool SubmitRating(RatingType type, string itemId, int rating) { string account = DBOption.GetOptions(DBOption.cOnlineUserID); if (String.IsNullOrEmpty(account)) { // if there is no tvdb account identifier, but we are using follwit. dont display the // "please fill in ID" error. if (FollwitConnector.Enabled) { return false; } string[] lines = new string[] { Translation.TVDB_INFO_ACCOUNTID_1, Translation.TVDB_INFO_ACCOUNTID_2 }; TVSeriesPlugin.ShowDialogOk(Translation.TVDB_INFO_TITLE, lines); MPTVSeriesLog.Write("Cannot submit rating, make sure you have your Account identifier set!"); return false; } if (itemId == "0" || rating < 0 || rating > 10) { MPTVSeriesLog.Write("Cannot submit rating, invalid values.....this is most likely a programming error"); return false; } if (!DBOnlineMirror.IsMirrorsAvailable) { // Server maybe available now. DBOnlineMirror.Init(); if (!DBOnlineMirror.IsMirrorsAvailable) { GUIDialogOK dlgOK = (GUIDialogOK)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_OK); dlgOK.SetHeading(Translation.TVDB_ERROR_TITLE); if (!TVSeriesPlugin.IsNetworkAvailable) { string[] lines = new string[] { Translation.NETWORK_ERROR_UNAVAILABLE_1, Translation.NETWORK_ERROR_UNAVAILABLE_2 }; TVSeriesPlugin.ShowDialogOk(Translation.TVDB_ERROR_TITLE, lines); } else { string[] lines = new string[] { Translation.TVDB_ERROR_UNAVAILABLE_1, Translation.TVDB_ERROR_UNAVAILABLE_2 }; TVSeriesPlugin.ShowDialogOk(Translation.TVDB_ERROR_TITLE, lines); } MPTVSeriesLog.Write("Cannot submit rating, the online database is unavailable"); return false; } } // ok we're good MPTVSeriesLog.Write(string.Format("Submitting Rating of {2} for {0} {1}", type.ToString(), itemId, rating), MPTVSeriesLog.LogLevel.Debug); Generic(string.Format(apiURIs.SubmitRating, account, type.ToString(), itemId, rating), true, false, Format.NoExtension); return true; }
/// <summary> /// This will write the text to the text box /// </summary> /// <param name="text">The text to be written</param> private void WriteIt(string text, RatingType rating) { string msg = (m_isPadding ? text.PadLeft(IndentSize * IndentLevel + text.Length) : text); StringBuilder sb = new StringBuilder(); sb.AppendFormat("[{0}] - {1}", DateTime.Now.ToString("HH:mm:ss:fff", System.Threading.Thread.CurrentThread.CurrentCulture.DateTimeFormat), msg); if (OnAudit != null) { OnAudit(this, new ScanAuditEventArgs(sb.ToString(), rating)); } }
public void ModifyRating(LibraryItem libraryItem, RatingType rating) { _databaseAccessor.UpdateLibraryRating(libraryItem.Id, rating); libraryItem.ModifyRating(rating); }
public void UpdateLibraryRating(long id, RatingType rating) { SqlExecuter.Execute(SQLResource.UpdateLibraryRating, new { Id = id, Rating = (int)rating }); }