/// <summary> /// Synchronizes names for an event, including possible names inherited from the series. /// </summary> /// <param name="ctx">Database context. Cannot be null.</param> /// <param name="ev">Event to be updated. Cannot be null.</param> /// <param name="seriesLink">Linked series. Can be null.</param> /// <param name="customName">Whether event uses custom name.</param> /// <param name="seriesNumber">Series number.</param> /// <param name="seriesSuffix">Series suffix.</param> /// <param name="nameContracts">Given names for event.</param> /// <returns>True if the names were changed, otherwise false.</returns> /// <exception cref="DuplicateEventNameException">If duplicate names are detected.</exception> /// <remarks> /// If series is specified and custom name setting is disabled, then event names are generated based on series names. /// If custom name is enabled or no series is specified, given names are used. /// Default name language is inherited from series as well, but that setting is not touched by this method. /// </remarks> public bool UpdateNames(IDatabaseContext ctx, ReleaseEvent ev, IEntryWithIntId seriesLink, bool customName, int seriesNumber, string seriesSuffix, IEnumerable <ILocalizedString> nameContracts) { var names = GetNames(ctx, seriesLink, customName, seriesNumber, seriesSuffix, nameContracts).ToArray(); var namesValues = names.Select(n => n.Value).ToArray(); CheckDuplicateName(ctx, namesValues, ev.Id); var changed = SaveNames(ctx, ev, names); return(changed); }
private IEnumerable <ILocalizedString> GetNames(IDatabaseContext ctx, IEntryWithIntId seriesLink, bool customName, int seriesNumber, string seriesSuffix, IEnumerable <ILocalizedString> nameContracts) { var series = ctx.NullSafeLoad <ReleaseEventSeries>(seriesLink); var names = series != null && !customName ? series.Names.Select(seriesName => new LocalizedStringContract(series.GetEventName(seriesNumber, seriesSuffix, seriesName.Value), seriesName.Language)) : nameContracts; return(names); }
public static int IdOrDefault(this IEntryWithIntId entry) { return(entry != null ? entry.Id : 0); }
public static bool IdEquals(this IEntryWithIntId left, IEntryWithIntId right) { return(left.Id == right.Id); }
/// <summary> /// Compares the Id of this entry with another. /// Null values and entries where the Id is undefined (0) will be handled. /// </summary> /// <param name="left">First entry to be compared. Can be null.</param> /// <param name="right">Second entry to be compared. Can be null.</param> /// <returns>True if entries on both sides are equal.</returns> /// <remarks> /// Null values and entries with undefined (0) Id will be considered equal. /// That means, /// null + 0 == true /// null + null == true /// 0 + 0 == true /// 39 + 39 == true /// null + 39 == false /// 0 + 39 == false /// </remarks> public static bool NullSafeIdEquals(this IEntryWithIntId left, IEntryWithIntId right) { return(left.IdOrDefault() == right.IdOrDefault()); }
public static T NullSafeLoad <T>(this IDatabaseContext <T> ctx, IEntryWithIntId entry) { return(entry != null && entry.Id != 0 ? ctx.Load(entry.Id) : default);
public static T LoadEntry <T>(this IDatabaseContext ctx, IEntryWithIntId entry) where T : class, IDatabaseObject => ctx.Load <T>(entry.Id);
public static T LoadEntry <T>(this IDatabaseContext ctx, IEntryWithIntId entry) => ctx.Load <T>(entry.Id);
/// <summary> /// Loads an entry based on a reference, or returns null if the reference is null or points to an entry that shouldn't exist (Id is 0). /// </summary> /// <typeparam name="T">Type of entry to be loaded.</typeparam> /// <param name="ctx">Repository context. Cannot be null.</param> /// <param name="entry">Entry reference. Can be null in which case null is returned.</param> /// <returns>Reference to the loaded entry. Can be null if <paramref name="entry"/> is null or Id is 0.</returns> public static T NullSafeLoad <T>(this IRepositoryContext <T> ctx, IEntryWithIntId entry) { return(entry != null && entry.Id != 0 ? ctx.Load(entry.Id) : default(T)); }
public static bool IdEquals(this IEntryWithIntId left, IEntryWithIntId right) { return left.Id == right.Id; }
/// <summary> /// Compares the Id of this entry with another. /// Null values and entries where the Id is undefined (0) will be handled. /// </summary> /// <param name="left">First entry to be compared. Can be null.</param> /// <param name="right">Second entry to be compared. Can be null.</param> /// <returns>True if entries on both sides are equal.</returns> /// <remarks> /// Null values and entries with undefined (0) Id will be considered equal. /// That means, /// null + 0 == true /// null + null == true /// 0 + 0 == true /// 39 + 39 == true /// null + 39 == false /// 0 + 39 == false /// </remarks> public static bool NullSafeIdEquals(this IEntryWithIntId left, IEntryWithIntId right) { return left.IdOrDefault() == right.IdOrDefault(); }
public static bool IsNullOrDefault(this IEntryWithIntId entry) { return(entry == null || entry.Id == 0); }