/// <summary>
/// Add list of different slots
/// </summary>
/// <param name="slotsArray"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <bool> AddListOfSlots(IEnumerable <SlotsReturnContract> slotsArray, CancellationToken cancellationToken)
{
var slotsReturnContracts = slotsArray as SlotsReturnContract[] ?? slotsArray.ToArray();
if (!slotsReturnContracts.Any())
{
_logger.LogInformation("Slot array is empty");
return(false);
}
var slots = slotsReturnContracts.Select(SlotsMapping.SlotMapFromContractToModel);
try
{
await _dbContext.AddRangeAsync(slots, cancellationToken);
await _dbContext.SaveChangesAsync(cancellationToken);
}
catch
{
_logger.LogInformation("Slot array is not added");
return(false);
}
return(true);
}
public async Task <IActionResult> Index(PostViewModel pvm)
{
if (ModelState.IsValid)
{
var text = "";
using (var stream = pvm.File.OpenReadStream())
using (var reader = new StreamReader(stream))
{
text = await reader.ReadToEndAsync();
}
var listResult = text.Parse(pvm.Word);
await context.AddRangeAsync(listResult);
await context.SaveChangesAsync();
}
return(RedirectToAction("Index"));
}
public async Task ActorsAreRetrievedTest()
{
using (var db = new ApplicationContext(Utilities.TestDbContextOptions()))
{
// Arrange: seed database with actors
var expectedActors = SeedData.GetSeedingActors();
await db.AddRangeAsync(expectedActors);
await db.SaveChangesAsync();
// Act: retrieve seeded actors from database
var result = await db.GetActorsAsync();
// Assert: seeded and retrieved actors match
var actualActors = Assert.IsAssignableFrom <List <Actor> >(result);
Assert.Equal(
expectedActors.OrderBy(a => a.ID).Select(a => a.Name),
actualActors.OrderBy(a => a.ID).Select(a => a.Name));
}
}
private async Task InsertPackageAsync()
{
if (_packetObject.Count > 0)
{
Sw.Stop();
System.Console.WriteLine($"Парсинг пачки: {Sw.ElapsedMilliseconds} ms.");
Sw.Reset();
Sw.Start();
await _context.AddRangeAsync(_packetObject);
await _context.SaveChangesAsync();
Sw.Stop();
System.Console.WriteLine($"Запись пачки в бд: {Sw.ElapsedMilliseconds} ms.");
Sw.Reset();
Sw.Start();
_packetObject.Clear();
}
}
protected override async Task InitializeAsync(ApplicationContext dbContext)
{
var roleNames = Enum
.GetNames(typeof(Role.Types));
var existingRoles = dbContext
.Roles
.Select(x => x.Name)
.ToArray();
if (roleNames.Length != existingRoles.Length)
{
var newRoles = roleNames
.Where(role => existingRoles.All(x => x != role))
.Select(x => new Role(x)
{
NormalizedName = x.ToUpperInvariant()
})
.ToList();
await dbContext.AddRangeAsync(newRoles);
}
}
public async Task <ActionResult> Index()
{
if (!_context.Users.Any())
{
using var httpClient = new HttpClient();
using var response = await httpClient.GetAsync("https://jsonplaceholder.typicode.com/users");
string apiResponse = await response.Content.ReadAsStringAsync();
var userList = JsonSerializer.Deserialize <List <User> >(apiResponse, new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
await _context.AddRangeAsync(userList);
await _context.SaveChangesAsync();
return(View(userList));
}
else
{
return(View(await _context.Users.ToListAsync()));
}
}
public virtual Task AddRangeAsync(IEnumerable <T> entity) => _context.AddRangeAsync(entity);
private async Task <IViewComponentResult> VkLoadAsync(VkUser vkUser, VkGroup vkGroup,
Models.User user, Models.Order order,
string photo, bool isPremium, string groupId, string isLoad)
{
try
{
var toLoad = true;
if (!isPremium)
{
var firstId = (await _context.VkGroupSet
.FirstOrDefaultAsync(id => id.VkUserId == vkUser.VkUserId)).VkGroupId;
toLoad = vkGroup.VkGroupId == firstId;
}
// Не грузить левые группы, для непремиум
if (toLoad)
{
var vkGroupFrom = await _context.VkGroupFromSet
.Include(inf => inf.GroupInfo)
.Include(set => set.Filter)
.Where(g => g.VkGroupId == vkGroup.VkGroupId)
.Take(isPremium ? 20 : 10)
.AsNoTracking()
.ToListAsync();
if (isLoad == "true" && vkGroupFrom != null && vkGroupFrom.Count > 0)
{
Stopwatch sw = Stopwatch.StartNew();
var oldItem = await _context.VkGroupSet
.Where(g => g.VkGroupId == groupId)
.SelectMany(g => g.VkGroupsFrom
.SelectMany(gr => gr.WallGets
.SelectMany(wall => wall.Items.Select(item => new VkItemViewModel
{
Text = item.Text,
Date = item.Date
}))))
.AsNoTracking()
.ToListAsync();
var count = vkGroup.MaxFrom ?? (TAKE / vkGroupFrom.Count) * 2;
var responses = new List <WallGet>(vkGroupFrom.Count);
if (vkUser != null)
{
foreach (var group in vkGroupFrom)
{
var onlyGroup = vkGroup.Filter?.GetOnlyGroupPost == true ||
group.Filter?.GetOnlyGroupPost == true;
var result = await _vkService.WallGetAsync(vkUser.AccessToken,
$"{count}", "0", $"-{group.GroupId}", group.Domain, onlyGroup);
if (!result.Contains("error_code"))
{
WallGet wallGetResponse = _jsonService.JsonConvertDeserializeObject <WallGetResponse>(result)?
.Response;
if (wallGetResponse != null)
{
wallGetResponse = await _textService.SortedTextAsync(wallGetResponse, oldItem);
for (int i = 0; i < wallGetResponse.Items.Count; i++)
{
var item = wallGetResponse.Items[i];
var tag = $"{group.Atribute} {vkGroup.Atribute}".Trim(' ');
item.Text = await _textService.TextFilterAsync(item.Text, vkGroup.Filter, group.Filter);
item.Text = _textService.AddTag(item.Text, tag);
}
wallGetResponse.VkGroupFromId = group.VkGroupFromId;
responses.Add(wallGetResponse);
}
}
else
{
await _telegramService.SendMessage(result);
}
}
}
await _context.AddRangeAsync(responses);
await _context.SaveChangesAsync();
sw.Stop();
await _telegramService.SendMessage($"time1: {sw.Elapsed.TotalMilliseconds}");
sw = Stopwatch.StartNew();
DateTime dateNow = DateTime.Now;
long unixTime = ((DateTimeOffset)dateNow).ToUnixTimeSeconds() - 30 * 60;
var date = DateTime.Now;
var take = vkGroup.MaxLoad ?? TAKE;
var vkItem = (await _context.VkGroupSet
.Where(g => g.VkGroupId == groupId)
.SelectMany(g => g.VkGroupsFrom
.SelectMany(gr => gr.WallGets
.SelectMany(wall => wall.Items
.Where(st =>
string.IsNullOrWhiteSpace(st.Statuse) ||
(st.Statuse == "Selected" && st.AddedTime < unixTime)
))))
.OrderByDescending(ch => ch.Statuse == "Selected")
.Take(take)
.Select(item => new
{
Filter = item.WallGet.VkGroupFrom.Filter,
Atribute = item.WallGet.VkGroupFrom.Atribute,
Statuse = item.Statuse,
GroupInfo = item.WallGet.VkGroupFrom.GroupInfo,
ItemId = item.ItemId,
Likes = item.Likes.Count,
Reposts = item.Reposts.Count,
Views = item.Views.Count,
Date = item.Date,
GifPrew = item.Attachments.Select(doc =>
new
{
Gif = doc.Doc.Url,
DocExt = doc.Doc.Ext,
Preview = doc.Doc.Preview.Photo.Sizes
}),
Photo = item.Attachments.Select(ph => ph.Photo.Photo604),
Text = item.Text
})
.AsNoTracking()
.ToListAsync())
.Select(item => new VkItemViewModel
{
Filter = item.Filter,
Atribute = item.Atribute,
Statuse = item.Statuse,
GroupInfo = item.GroupInfo,
ItemId = item.ItemId,
Likes = item.Likes,
Reposts = item.Reposts,
Views = item.Views,
Date = item.Date,
GifPrew = item.GifPrew.Select(doc =>
new GifPreviewViewModel
{
Gif = doc.Gif,
DocExt = doc.DocExt,
PreviewPhoto = doc.Preview.ToList()
}).ToList(),
Photo = item.Photo.ToList(),
Text = item.Text
});
vkItem = await _textService.SortingItemAsync(vkItem, vkGroup.Filter);
sw.Stop();
await _telegramService.SendMessage($"time2: {sw.Elapsed.TotalMilliseconds}");
return(View(new VkResponseAndGroupVk
{
Responses = vkItem.OrderByDescending(ch => Tuple.Create(ch.Statuse == "Selected", ch.Likes + ch.Reposts, ch.Likes, ch.Reposts, ch.Views)),
VkGroupViewModel = new VkGroupViewModel
{
VkGroupId = groupId,
VkGroupsFrom = vkGroupFrom,
Photo = photo,
Domain = vkGroup?.GroupInfo?.ScreenName ?? vkGroup?.Domain,
GroupName = vkGroup?.GroupInfo.Name
},
AttributeAll = vkGroup.Atribute,
}));
}
return(View(new VkResponseAndGroupVk
{
VkGroupViewModel = new VkGroupViewModel
{
VkGroupId = groupId,
VkGroupsFrom = vkGroupFrom,
Photo = photo,
Domain = vkGroup?.GroupInfo?.ScreenName ?? vkGroup?.Domain,
GroupName = vkGroup?.GroupInfo.Name
},
AttributeAll = vkGroup.Atribute
}));
}
}
catch (Exception ex)
{
await _telegramService.SendMessageExceptionAsync(ex);
}
return(View());
}
public async Task <bool> AddRangeAsync(IEnumerable <Product> products)
{
await DBContext.AddRangeAsync(products);
return(true);
}
/// <inheritdoc />
/// <exception cref="UserNotFoundException">Thrown when the user is not found</exception>
public async Task <EventViewModel> Create(CreateEventBody createEventBody)
{
var host = await ApplicationContext.Users.AsSplitQuery().Include(x => x.HostedEvents)
.FirstOrDefaultAsync(x => x.Id == createEventBody.HostId);
if (host == null)
{
Logger.LogInformation("User not found");
throw new UserNotFoundException();
}
// get coordinates of the address
if (createEventBody.Address != null)
{
var cords = await GetAddressCords(createEventBody.Address);
createEventBody.Address.Lat = cords.Lat;
createEventBody.Address.Lon = cords.Lon;
}
var newEvent = new Event()
{
Name = createEventBody.Name,
Description = createEventBody.Description,
// Address = new Address(),
isCanceled = false,
Price = createEventBody.Price,
IsOnline = createEventBody.IsOnline,
EndLocal = createEventBody.EndLocal,
EndUTC = createEventBody.EndLocal.ToUniversalTime(),
StartLocal = createEventBody.StartLocal,
StartUTC = createEventBody.StartLocal.ToUniversalTime(),
Images = createEventBody.Images.Select(x => Mapper.Map <Image>(x)).ToList(),
Thumbnail = createEventBody.Thumbnail != null
? Mapper.Map <Image>(createEventBody.Thumbnail)
: new Image(),
SocialLinks = createEventBody.SocialLinks != null
? createEventBody.SocialLinks.Select(x => Mapper.Map <SocialLink>(x)).ToList()
: new List <SocialLink>(),
TicketsLeft = createEventBody.NumberOfTickets,
Created = new DateTime(),
Finished = false
};
// generate tickets for event
List <Ticket> tickets = new List <Ticket>();
for (int i = 0; i < createEventBody.NumberOfTickets; i++)
{
tickets.Add(new Ticket()
{
Event = newEvent,
Available = true,
Uses = 0
});
}
host.HostedEvents.Add(newEvent);
try
{
// Saving user to Db.
await ApplicationContext.Events.AddAsync(newEvent);
await ApplicationContext.Tickets.AddRangeAsync(tickets);
await ApplicationContext.SaveChangesAsync();
if (createEventBody.Categories != null)
{
List <EventCategory> eventCategories = createEventBody.Categories
.Select(c => new EventCategory()
{
CategoryId = c.Id, EventId = newEvent.Id
}).ToList();
await ApplicationContext.AddRangeAsync(eventCategories);
await ApplicationContext.SaveChangesAsync();
}
return(Mapper.Map <EventViewModel>(newEvent));
}
catch
{
Logger.LogWarning("User failed to save");
throw;
}
}
