public async Task <Dish> AddFavoriteDishAsync(int loggedUser, int dishId)
{
var dish = await GetDishByIdAsync(dishId);
var exist = await _uow.FavoriteDishRepository.GetAll()
.Where(fd => fd.DishId == dishId && fd.UserId == loggedUser)
.FirstOrDefaultAsync();
if (exist != null)
{
return(dish);
}
var favoriteDish = new FavoriteDish
{
UserId = loggedUser,
DishId = dishId
};
await _uow.FavoriteDishRepository.AddAsync(favoriteDish);
await _uow.CommitAsync();
QueryCacheManager.ExpireTag(_config.GetSection("AWS")["CachePrefix"] + CacheEntries.ALL_DISHES);
return(dish);
}
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_anonymous_types()
{
var metadataWorkspaceMock = new Mock <MetadataWorkspace>();
metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create());
var edmProperties = new []
{
new EdmProperty("P1Int", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32),
new FacetValues {
Nullable = false
})),
new EdmProperty("P2Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean)))
};
var cSpaceEntityType = new RowType(edmProperties);
var entityTypeUsage = TypeUsage.Create(cSpaceEntityType);
var recordMap = new RecordColumnMap(
entityTypeUsage, "E",
new[] { new ScalarColumnMap(cSpaceEntityType.Properties[0].TypeUsage, cSpaceEntityType.Properties[0].Name, 0, 0) },
new ScalarColumnMap(cSpaceEntityType.Properties[1].TypeUsage, cSpaceEntityType.Properties[1].Name, 0, 1));
var collectionMap = new SimpleCollectionColumnMap(
entityTypeUsage, "MockCollectionType", recordMap, null, null);
var factory =
new Translator().TranslateColumnMap <object>(
collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false);
Assert.NotNull(factory);
Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes);
Assert.Equal(new[] { true, true }, factory.NullableColumns);
}
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_complex_types()
{
var metadataWorkspaceMock = new Mock <MetadataWorkspace>();
metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create());
var cSpaceComplexType = new ComplexType("C");
var intTypeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues {
Nullable = false
});
cSpaceComplexType.AddMember(new EdmProperty("Id", intTypeUsage));
cSpaceComplexType.AddMember(new EdmProperty("Count", intTypeUsage));
var complexTypeUsage = TypeUsage.Create(cSpaceComplexType);
var recordMap = new ComplexTypeColumnMap(
complexTypeUsage, "E",
new[] { new ScalarColumnMap(cSpaceComplexType.Properties[0].TypeUsage, cSpaceComplexType.Properties[0].Name, 0, 0) },
new ScalarColumnMap(cSpaceComplexType.Properties[1].TypeUsage, cSpaceComplexType.Properties[1].Name, 0, 1));
var collectionMap = new SimpleCollectionColumnMap(
complexTypeUsage, "MockCollectionType", recordMap, null, null);
metadataWorkspaceMock.Setup(m => m.GetItem <EdmType>(It.IsAny <string>(), DataSpace.OSpace))
.Returns(new CodeFirstOSpaceTypeFactory().TryCreateType(typeof(SimpleEntity), cSpaceComplexType));
var factory =
new Translator().TranslateColumnMap <object>(
collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false);
Assert.NotNull(factory);
Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes);
Assert.Equal(new[] { true, true }, factory.NullableColumns);
}
public void None()
{
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 3);
using (var ctx = new TestContext())
{
var query = ctx.Entity_Basics.Where(x => x.ColumnInt > 0);
var cacheKey1 = QueryCacheManager.GetCacheKey(query, new string[0]);
QueryCacheManager.UseTagsAsCacheKey = true;
try
{
var cacheKey2 = QueryCacheManager.GetCacheKey(query, new string[0]);
}
catch (Exception ex)
{
Assert.AreEqual(ExceptionMessage.QueryCache_UseTagsNullOrEmpty, ex.Message);
}
finally
{
QueryCacheManager.UseTagsAsCacheKey = false;
}
}
}
public async Task AddGlobalEmotesAsync()
{
var user = Context.User as SocketGuildUser;
if (user == null)
{
return;
}
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(user.Id);
if (botuser.TcCnt < 4000)
{
await ReplyAsync("", embed : $"{user.Mention} nie posiadasz wystarczającej liczby TC!".ToEmbedMessage(EMType.Error).Build());
return;
}
using (var cdb = new Database.GuildConfigContext(Config))
{
var gConfig = await cdb.GetCachedGuildFullConfigAsync(Context.Guild.Id);
var gRole = Context.Guild.GetRole(gConfig.GlobalEmotesRole);
if (gRole == null)
{
await ReplyAsync("", embed : "Serwer nie ma ustawionej roli globalnych emotek.".ToEmbedMessage(EMType.Bot).Build());
return;
}
var global = botuser.TimeStatuses.FirstOrDefault(x => x.Type == Database.Models.StatusType.Globals && x.Guild == Context.Guild.Id);
if (global == null)
{
global = new Database.Models.TimeStatus
{
Type = StatusType.Globals,
Guild = Context.Guild.Id,
EndsAt = DateTime.Now,
};
botuser.TimeStatuses.Add(global);
}
if (!user.Roles.Contains(gRole))
{
await user.AddRoleAsync(gRole);
}
global.EndsAt = global.EndsAt.AddMonths(1);
botuser.TcCnt -= 4000;
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}", "users" });
await ReplyAsync("", embed : $"{user.Mention} wykupił miesiąc globalnych emotek!".ToEmbedMessage(EMType.Success).Build());
}
}
public async Task SlotMachineSettingsAsync([Summary("typ nastaw(info - wyświetla informacje)")] SlotMachineSetting setting = SlotMachineSetting.Info, [Summary("wartość nastawy")] string value = "info")
{
if (setting == SlotMachineSetting.Info)
{
await ReplyAsync("", false, $"{_fun.GetSlotMachineInfo()}".ToEmbedMessage(EMType.Info).Build());
return;
}
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(Context.User.Id);
if (!botuser.ApplySlotMachineSetting(setting, value))
{
await ReplyAsync("", embed : $"Podano niewłaściwą wartość parametru!".ToEmbedMessage(EMType.Error).Build());
return;
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}", "users" });
}
await ReplyAsync("", embed : $"{Context.User.Mention} zmienił nastawy automatu.".ToEmbedMessage(EMType.Success).Build());
}
public async Task GiveDailyScAsync()
{
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(Context.User.Id);
var daily = botuser.TimeStatuses.FirstOrDefault(x => x.Type == Database.Models.StatusType.Daily);
if (daily == null)
{
daily = new Database.Models.TimeStatus
{
Type = Database.Models.StatusType.Daily,
EndsAt = DateTime.MinValue
};
botuser.TimeStatuses.Add(daily);
}
if (daily.IsActive())
{
var timeTo = (int)daily.RemainingMinutes();
await ReplyAsync("", embed : $"{Context.User.Mention} następne drobne możesz otrzymać dopiero za {timeTo / 60}h {timeTo % 60}m!".ToEmbedMessage(EMType.Error).Build());
return;
}
daily.EndsAt = DateTime.Now.AddHours(20);
botuser.ScCnt += 100;
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}" });
await ReplyAsync("", embed : $"{Context.User.Mention} łap drobne na waciki!".ToEmbedMessage(EMType.Success).Build());
}
}
public async Task ChangeTitleCardAsync([Summary("WID")] ulong wid, [Summary("tytuł")][Remainder] string title = null)
{
using (var db = new Database.UserContext(Config))
{
var thisCard = db.Cards.FirstOrDefault(x => x.Id == wid);
if (thisCard == null)
{
await ReplyAsync("", embed : $"Taka karta nie istnieje.".ToEmbedMessage(EMType.Error).Build());
return;
}
if (title != null)
{
thisCard.Title = title;
}
else
{
var res = await _shClient.GetCharacterInfoAsync(thisCard.Character);
if (res.IsSuccessStatusCode())
{
thisCard.Title = res.Body?.Relations?.OrderBy(x => x.Id)?.FirstOrDefault()?.Title ?? "????";
}
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { "users" });
await ReplyAsync("", embed : $"Nowy tytuł to: `{thisCard.Title}`".ToEmbedMessage(EMType.Success).Build());
}
}
public async Task GenerateItemAsync([Summary("użytkownik")] SocketGuildUser user, [Summary("przedmiot")] ItemType itemType, [Summary("liczba przedmiotów")] uint count = 1,
[Summary("jakość przedmiotu")] Quality quality = Quality.Broken)
{
var item = itemType.ToItem(count, quality);
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(user.Id);
var thisItem = botuser.GameDeck.Items.FirstOrDefault(x => x.Type == item.Type && x.Quality == item.Quality);
if (thisItem == null)
{
thisItem = item;
botuser.GameDeck.Items.Add(thisItem);
}
else
{
thisItem.Count += count;
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}", "users" });
string cnt = (count > 1) ? $" x{count}" : "";
await ReplyAsync("", embed : $"{user.Mention} otrzymał _{item.Name}_{cnt}.".ToEmbedMessage(EMType.Success).Build());
}
}
public async Task RestoreCardsAsync([Summary("użytkownik")] SocketGuildUser user)
{
using (var db = new Database.UserContext(Config))
{
var bUser = await db.GetUserOrCreateAsync(user.Id);
var thisCards = db.Cards.Include(x => x.TagList).Where(x => (x.LastIdOwner == user.Id || (x.FirstIdOwner == user.Id && x.LastIdOwner == 0)) && x.GameDeckId == 1).ToList();
if (thisCards.Count < 1)
{
await ReplyAsync("", embed : "Nie odnaleziono kart!".ToEmbedMessage(EMType.Bot).Build());
return;
}
string reply = $"Karta {thisCards.First().GetString(false, false, true)} została przeniesiona.";
if (thisCards.Count > 1)
{
reply = $"Przeniesiono {thisCards.Count} kart.";
}
foreach (var thisCard in thisCards)
{
thisCard.Active = false;
thisCard.InCage = false;
thisCard.TagList.Clear();
thisCard.GameDeckId = user.Id;
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{Context.User.Id}", "users" });
await ReplyAsync("", embed : reply.ToEmbedMessage(EMType.Success).Build());
}
}
public async Task FactoryUserAsync([Summary("id użytkownika")] ulong id, [Summary("czy usunąć karty?")] bool cards = false)
{
using (var db = new Database.UserContext(Config))
{
var fakeu = await db.GetUserOrCreateAsync(1);
var user = await db.GetUserOrCreateAsync(id);
if (!cards)
{
foreach (var card in user.GameDeck.Cards)
{
card.InCage = false;
card.TagList.Clear();
card.LastIdOwner = id;
fakeu.GameDeck.Cards.Add(card);
}
user.GameDeck.Cards.Clear();
}
db.Users.Remove(user);
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { "users", $"user-{id}" });
}
await ReplyAsync("", embed : $"Użytkownik o id: `{id}` został wymazany.".ToEmbedMessage(EMType.Success).Build());
}
public async Task TransferCardAsync([Summary("użytkownik")] SocketGuildUser user, [Summary("WIDs")] params ulong[] wids)
{
using (var db = new Database.UserContext(Config))
{
var thisCards = db.Cards.Include(x => x.TagList).Where(x => wids.Any(c => c == x.Id)).ToList();
if (thisCards.Count < 1)
{
await ReplyAsync("", embed : "Nie odnaleziono kart!".ToEmbedMessage(EMType.Bot).Build());
return;
}
string reply = $"Karta {thisCards.First().GetString(false, false, true)} została przeniesiona.";
if (thisCards.Count > 1)
{
reply = $"Przeniesiono {thisCards.Count} kart.";
}
foreach (var thisCard in thisCards)
{
thisCard.Active = false;
thisCard.InCage = false;
thisCard.TagList.Clear();
thisCard.GameDeckId = user.Id;
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{Context.User.Id}", "users" });
await ReplyAsync("", embed : reply.ToEmbedMessage(EMType.Success).Build());
}
}
public async Task ForceUpdateCardsAsync([Summary("WID kart")] params ulong[] ids)
{
using (var db = new Database.UserContext(Config))
{
var cards = db.Cards.Where(x => ids.Any(c => c == x.Id)).ToList();
if (cards.Count < 1)
{
await ReplyAsync("", embed : $"{Context.User.Mention} nie odnaleziono kart.".ToEmbedMessage(EMType.Error).Build());
return;
}
foreach (var card in cards)
{
try
{
await card.Update(null, _shClient);
_waifu.DeleteCardImageIfExist(card);
}
catch (Exception) { }
}
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"users" });
await ReplyAsync("", embed : $"Zaktualizowano {cards.Count} kart.".ToEmbedMessage(EMType.Success).Build());
}
}
public void Static_TranslateColumnMap_calls_instance_method()
{
var typeUsageMock = new Mock <TypeUsage>();
var expectedShaperFactory = new ShaperFactory <object>(
0, Objects.MockHelper.CreateCoordinatorFactory <object>(), null,
MergeOption.AppendOnly);
var translatorMock = new Mock <Translator>();
translatorMock.Setup(
m => m.TranslateColumnMap <object>(
It.IsAny <QueryCacheManager>(), It.IsAny <ColumnMap>(), It.IsAny <MetadataWorkspace>(),
It.IsAny <SpanIndex>(), It.IsAny <MergeOption>(), It.IsAny <bool>())).Returns(expectedShaperFactory);
var actualShaperFactory = Translator.TranslateColumnMap(
translatorMock.Object, typeof(object), QueryCacheManager.Create(),
new ScalarColumnMap(typeUsageMock.Object, null, 0, 0), new MetadataWorkspace(),
new SpanIndex(), MergeOption.AppendOnly, valueLayer: true);
translatorMock.Verify(
m => m.TranslateColumnMap <object>(
It.IsAny <QueryCacheManager>(), It.IsAny <ColumnMap>(), It.IsAny <MetadataWorkspace>(),
It.IsAny <SpanIndex>(), It.IsAny <MergeOption>(), It.IsAny <bool>()), Times.Once());
Assert.Same(expectedShaperFactory, actualShaperFactory);
}
private Executable GetSafariExe(EmbedBuilder embed, IUserMessage msg, Card newCard,
SafariImage pokeImage, ICharacterInfo character, ITextChannel trashChannel, IUser winner)
{
return(new Executable("safari", new Task(() =>
{
using (var db = new Database.UserContext(_config))
{
var botUser = db.GetUserOrCreateAsync(winner.Id).Result;
newCard.FirstIdOwner = winner.Id;
newCard.Affection += botUser.GameDeck.AffectionFromKarma();
botUser.GameDeck.RemoveCharacterFromWishList(newCard.Character);
botUser.GameDeck.Cards.Add(newCard);
db.SaveChanges();
QueryCacheManager.ExpireTag(new string[] { $"user-{botUser.Id}", "users" });
using (var dba = new Database.AnalyticsContext(_config))
{
dba.UsersData.Add(new Database.Models.Analytics.UserAnalytics
{
Value = 1,
UserId = winner.Id,
MeasureDate = DateTime.Now,
GuildId = trashChannel?.Guild?.Id ?? 0,
Type = Database.Models.Analytics.UserAnalyticsEventType.Card
});
dba.SaveChanges();
}
}
_ = Task.Run(async() =>
{
try
{
embed.ImageUrl = await _waifu.GetSafariViewAsync(pokeImage, newCard, trashChannel);
embed.Description = $"{winner.Mention} zdobył na polowaniu i wsadził do klatki:\n"
+ $"{newCard.GetString(false, false, true)}\n({newCard.Title})";
await msg.ModifyAsync(x => x.Embed = embed.Build());
var privEmb = new EmbedBuilder()
{
Color = EMType.Info.Color(),
Description = $"Na [polowaniu]({msg.GetJumpUrl()}) zdobyłeś: {newCard.GetString(false, false, true)}"
};
var priv = await winner.GetOrCreateDMChannelAsync();
if (priv != null)
{
await priv.SendMessageAsync("", false, privEmb.Build());
}
}
catch (Exception ex)
{
_logger.Log($"In Safari: {ex}");
}
});
})));
}
public virtual async Task UpdateAsync(TblCurrencies record)
{
if (await _dbContext.Languages
.DeferredAny(p => p.IsoCode.Trim() == record.IsoCode.Trim() && p.Id != record.Id)
.FromCacheAsync(CacheTags.Currency))
{
throw new Exception($"The \"{record.IsoCode}\" ISO code already exist.");
}
var oldRecord = await FindByIdAsync(record.Id);
if (oldRecord != null)
{
if (oldRecord.IsMainCurrency && !record.Published)
{
throw new Exception("System default currency cannot be at unpublished status.");
}
_dbContext.Currencies.AddOrUpdate(record);
await _dbContext.SaveChangesAsync();
QueryCacheManager.ExpireTag(CacheTags.Currency);
_eventPublisher.EntityUpdated(record, oldRecord);
}
}
public void Single()
{
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 3);
using (var ctx = new TestContext())
{
var firstTag = "zzzprojects";
StringBuilder cacheKey = new StringBuilder();
cacheKey.AppendLine(QueryCacheManager.CachePrefix);
cacheKey.AppendLine(QueryCacheManager.GetConnectionStringForCacheKey(ctx.Entity_Basics));
cacheKey.AppendLine(firstTag);
var query = ctx.Entity_Basics.Where(x => x.ColumnInt > 0);
var cacheKey1 = QueryCacheManager.GetCacheKey(query, new string[0]);
QueryCacheManager.UseFirstTagAsCacheKey = true;
var cacheKey2 = QueryCacheManager.GetCacheKey(query, new[] { firstTag });
QueryCacheManager.UseFirstTagAsCacheKey = false;
// Cache key are different
Assert.AreNotEqual(cacheKey1, cacheKey2);
// Cache key2 is equal to hardcoded cacheKey
Assert.AreEqual(cacheKey.ToString(), cacheKey2);
}
}
public virtual async Task SetAsDefaultAsync(int id)
{
var record = await _dbContext.Currencies.FirstOrDefaultAsync(p => p.Id == id);
if (record == null)
{
throw new Exception("Invalid currency Id.");
}
if (!record.Published)
{
throw new Exception("Unpublished currency cannot be used as the default currency.");
}
await _dbContext.Currencies
.UpdateAsync(p => new TblCurrencies()
{
IsMainCurrency = false
});
await _dbContext.Currencies.Where(p => p.Id == id)
.UpdateAsync(p => new TblCurrencies()
{
IsMainCurrency = true
});
QueryCacheManager.ExpireTag(CacheTags.Currency);
_eventPublisher.Publish(new DefaultCurrencyChangeEvent(record));
}
public async Task PlayOnSlotMachineAsync([Summary("typ(info - wyświetla informacje)")] string type = "game")
{
if (type != "game")
{
await ReplyAsync("", false, $"{_fun.GetSlotMachineGameInfo()}".ToEmbedMessage(EMType.Info).Build());
return;
}
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(Context.User.Id);
var machine = new SlotMachine(botuser);
var toPay = machine.ToPay();
if (botuser.ScCnt < toPay)
{
await ReplyAsync("", embed : $"{Context.User.Mention} brakuje Ci SC, aby za tyle zagrać.".ToEmbedMessage(EMType.Error).Build());
return;
}
var win = machine.Play(new SlotEqualRandom());
botuser.ScCnt += win - toPay;
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}", "users" });
await ReplyAsync("", embed : $"{_fun.GetSlotMachineResult(machine.Draw(), Context.User, botuser, win)}".ToEmbedMessage(EMType.Bot).Build());
}
}
/// <summary>
/// 修改
/// </summary>
/// <param name="model">修改后的实体</param>
/// <returns></returns>
public virtual int Modify <T>(DbContext db, T model) where T : class, new()
{
// 让使用typeof(T).Name标签的所有缓存过期
QueryCacheManager.ExpireTag(typeof(T).Name);
db.Entry(model).State = EntityState.Modified;
return(db.SaveChanges());
}
public async Task GiveHourlyScAsync()
{
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(Context.User.Id);
var hourly = botuser.TimeStatuses.FirstOrDefault(x => x.Type == Database.Models.StatusType.Hourly);
if (hourly == null)
{
hourly = new Database.Models.TimeStatus
{
Type = Database.Models.StatusType.Hourly,
EndsAt = DateTime.MinValue
};
botuser.TimeStatuses.Add(hourly);
}
if (hourly.IsActive())
{
var timeTo = (int)hourly.RemainingSeconds();
await ReplyAsync("", embed : $"{Context.User.Mention} następne zaskórniaki możesz otrzymać dopiero za {timeTo / 60}m {timeTo % 60}s!".ToEmbedMessage(EMType.Error).Build());
return;
}
hourly.EndsAt = DateTime.Now.AddHours(1);
botuser.ScCnt += 5;
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}", "users" });
await ReplyAsync("", embed : $"{Context.User.Mention} łap piątaka!".ToEmbedMessage(EMType.Success).Build());
}
}
/// <summary>
/// 批量修改（非lambda）
/// </summary>
/// <param name="model">要修改实体中 修改后的属性 </param>
/// <param name="whereLambda">查询实体的条件</param>
/// <param name="proNames">lambda的形式表示要修改的实体属性名</param>
/// <returns></returns>
public virtual int ModifyBy <T>(DbContext db, T model, Expression <Func <T, bool> > whereLambda, params string[] proNames) where T : class, new()
{
// 让使用typeof(T).Name标签的所有缓存过期
QueryCacheManager.ExpireTag(typeof(T).Name);
List <T> listModifes = db.Set <T>().Where(whereLambda).ToList();
Type t = typeof(T);
List <PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
Dictionary <string, PropertyInfo> dicPros = new Dictionary <string, PropertyInfo>();
proInfos.ForEach(p =>
{
if (proNames.Contains(p.Name))
{
dicPros.Add(p.Name, p);
}
});
foreach (string proName in proNames)
{
if (dicPros.ContainsKey(proName))
{
PropertyInfo proInfo = dicPros[proName];
object newValue = proInfo.GetValue(model, null);
foreach (T m in listModifes)
{
proInfo.SetValue(m, newValue, null);
}
}
}
return(db.SaveChanges());
}
public async Task ChangeBackgroundAsync([Summary("bezpośredni adres do obrazka (450 x 150)")] string imgUrl)
{
using (var db = new Database.UserContext(Config))
{
var botuser = await db.GetUserOrCreateAsync(Context.User.Id);
if (botuser.ScCnt < 5000)
{
await ReplyAsync("", embed : $"{Context.User.Mention} nie posiadasz wystarczającej liczby SC!".ToEmbedMessage(EMType.Error).Build());
return;
}
if (await _profile.SaveProfileImageAsync(imgUrl, $"./GOut/Saved/BG{botuser.Id}.png", 450, 150, true))
{
botuser.BackgroundProfileUri = $"./GOut/Saved/BG{botuser.Id}.png";
}
else
{
await ReplyAsync("", embed : "Nie wykryto obrazka! Upewnij się, że podałeś poprawny adres!".ToEmbedMessage(EMType.Error).Build());
return;
}
botuser.ScCnt -= 5000;
await db.SaveChangesAsync();
QueryCacheManager.ExpireTag(new string[] { $"user-{botuser.Id}", "users" });
await ReplyAsync("", embed : $"Zmieniono tło profilu użytkownika: {Context.User.Mention}!".ToEmbedMessage(EMType.Success).Build());
}
}
public void Tag_Expire()
{
var testCacheKey = Guid.NewGuid().ToString();
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 1);
using (var ctx = new TestContext())
{
// BEFORE
var itemCountBefore = ctx.Entity_Basics.FromCache(testCacheKey).Count();
var cacheCountBefore = QueryCacheHelper.GetCacheCount();
TestContext.DeleteAll(x => x.Entity_Basics);
QueryCacheManager.ExpireTag(testCacheKey);
var cacheCountExpired = QueryCacheHelper.GetCacheCount();
// TEST: The cache count are NOT equal (The cache key has been removed)
Assert.AreEqual(cacheCountBefore - 1, cacheCountExpired);
// AFTER
var itemCountAfter = ctx.Entity_Basics.FromCache(testCacheKey).Count();
var cacheCountAfter = QueryCacheHelper.GetCacheCount();
// TEST: The item count are NOT equal (The query has been expired)
Assert.AreNotEqual(itemCountBefore, itemCountAfter);
Assert.AreEqual(0, itemCountAfter);
// TEST: The cache count are NOT equal (The expired cache key is added)
Assert.AreEqual(cacheCountExpired + 1, cacheCountAfter);
Assert.AreEqual(cacheCountBefore, cacheCountAfter);
}
}
public void Queryable_WithExpiration()
{
QueryCacheManager.Cache = new MemoryCache(Guid.NewGuid().ToString());
TestContext.DeleteAll(x => x.Entity_Basics);
TestContext.Insert(x => x.Entity_Basics, 1);
using (var ctx = new TestContext())
{
// BEFORE
var itemCountBefore = ctx.Entity_Basics.FromCache(DateTime.Now.AddMinutes(2)).Count();
var cacheCountBefore = QueryCacheHelper.GetCacheCount();
TestContext.DeleteAll(x => x.Entity_Basics);
QueryCacheManager.ExpireAll();
// EXPIRED
var cacheCountExpired = QueryCacheHelper.GetCacheCount();
// AFTER
var itemCountAfter = ctx.Entity_Basics.FromCache(DateTime.Now.AddMinutes(2)).Count();
var cacheCountAfter = QueryCacheHelper.GetCacheCount();
// TEST: The item count are not equal
Assert.AreNotEqual(itemCountBefore, itemCountAfter);
// TEST: The cache count are equal
Assert.AreEqual(cacheCountBefore, cacheCountAfter);
// TEST: The cache count after ExpireAll call is zero
Assert.AreEqual(0, cacheCountExpired);
}
}
public async Task AddAsync(Language model)
{
_dbSet.Add(model);
await _unitOfWork.SaveChangesAsync();
QueryCacheManager.ExpireTag(CacheTags);
}
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_discriminated_types()
{
var metadataWorkspaceMock = new Mock <MetadataWorkspace>();
metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create());
var typeChoices = new Dictionary <object, TypedColumnMap>();
var entityColumnMap = (EntityColumnMap)BuildSimpleEntitySetColumnMap(metadataWorkspaceMock).Element;
typeChoices.Add(true, entityColumnMap);
var recordMap = new SimplePolymorphicColumnMap(
entityColumnMap.Type, "E", new ColumnMap[0],
new ScalarColumnMap(TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean)), "discriminator", 0, 2),
typeChoices);
var collectionMap = new SimpleCollectionColumnMap(
entityColumnMap.Type, "MockCollectionType", recordMap, null, null);
var factory =
new Translator().TranslateColumnMap <object>(
collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false);
Assert.NotNull(factory);
Assert.Equal(new[] { typeof(int), typeof(int), typeof(bool) }, factory.ColumnTypes);
Assert.Equal(new[] { true, true, true }, factory.NullableColumns);
}
public async Task UpdateAsync(Language model)
{
_unitOfWork.Update(model);
await _unitOfWork.SaveChangesAsync();
QueryCacheManager.ExpireTag(CacheTags);
}
public async Task <ServiceBasePayload> UpdateService(UpdateServiceInput input,
[ScopedService] ApplicationDbContext context, CancellationToken cancellationToken)
{
var service = await context.Service.DeferredFirst(x => x.Id == input.ServiceId).FromCacheAsync(cancellationToken);
if (service is null)
{
return(new ServiceBasePayload(
new UserError("Service with that id not found.", "SERVICE_NOT_FOUND")));
}
if (input.Name.HasValue)
{
service.Name = input.Name;
}
if (input.Description.HasValue)
{
service.Description = input.Description;
}
if (input.Url.HasValue)
{
service.Url = input.Url;
}
if (input.ParentId.HasValue)
{
service.Parent = await context.Service.DeferredFirst(x => x.Id == input.ParentId).FromCacheAsync(cancellationToken);
}
await context.SaveChangesAsync(cancellationToken);
QueryCacheManager.ExpireType <Service>();
return(new ServiceBasePayload(service));
}
public async Task DeleteDishAsync(int loggedUser, int id)
{
// validate admin user
var user = await _uow.UserRepository.FindByAsync(u => u.Id == loggedUser && u.Role == RoleEnum.ADMIN);
if (user.Count == 0)
{
throw new NotAllowedException(ExceptionConstants.NOT_ALLOWED);
}
var dish = await _uow.DishRepository.GetAsync(id);
if (dish == null)
{
throw new NotFoundException(ExceptionConstants.NOT_FOUND, "Dish");
}
if (!string.IsNullOrWhiteSpace(dish.Image))
{
await _fileService.DeleteFileAsync(dish.Image);
}
_uow.DishRepository.Delete(dish);
await _uow.CommitAsync();
//expire cache
QueryCacheManager.ExpireTag(_config.GetSection("AWS")["CachePrefix"] + CacheEntries.ALL_DISHES);
}
