1import axios from "./base/axios";
2import cookies from "js-cookie";
3import jwt from "jwt-decode";
4import { set } from "../context/features/accessTokenSlice";
5
6export const authenticate = async (dispatch, values) => {
7  let success = false;
8
9  await axios
10    .post("/authentication/authenticate", values)
11    .then(function (response) {
12      // Set refresh token in cookie
13      const decoded = jwt(response.data.refreshToken);
14      cookies.set("auth_jwt_refresh_token", response.data.refreshToken, {
15        expires: new Date(decoded.exp * 1000),
16      });
17
18      dispatch(set(response.data.accessToken));
19      success = true;
20    })
21    .catch(function (error) {
22      console.log(error);
23    });
24
25  return success;
26};
27
28export const renew = async (dispatch, refreshToken) => {
29  let success = false;
30
31  await axios
32    .post("/authentication/renew", { value: refreshToken })
33    .then(function (response) {
34      // Set refresh token in cookie
35      const decoded = jwt(response.data.refreshToken);
36      cookies.set("auth_jwt_refresh_token", response.data.refreshToken, {
37        expires: new Date(decoded.exp * 1000),
38      });
39
40      dispatch(set(response.data.accessToken));
41      success = true;
42    })
43    .catch(function (error) {
44      console.log(error);
45      cookies.remove("auth_jwt_refresh_token");
46    });
47
48  return success;
49};

1using Data;
2using Data.DTOs;
3using Infrastructure.Enums;
4using Infrastructure.Services;
5using Microsoft.EntityFrameworkCore;
6
7namespace Background
8{
9    public class OrderCollector : BackgroundService
10    {
11        private readonly ILogger<OrderCollector> _logger;
12        private ItemService itemService;
13
14        public OrderCollector(ILogger<OrderCollector> logger)
15        {
16            _logger = logger;
17
18            var optionsBuilder = new DbContextOptionsBuilder<DataContext>();
19            optionsBuilder.UseSqlServer(Configuration.DatabaseConnectionString);
20            itemService = new ItemService(new DataContext(optionsBuilder.Options));
21        }
22
23        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
24        {
25            while (!stoppingToken.IsCancellationRequested)
26            {
27                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
28
29                var itemsPendingOrders = itemService.GetItemsPendingOrders();
30
31                foreach (var itemPendingOrder in itemsPendingOrders)
32                {
33                    var itemHistory = itemService.GetHistory(itemPendingOrder.ID);
34
35                    if (itemHistory.Count() > 0)
36                    {
37                        var lastBidding = itemHistory.OrderByDescending(x => x.BidAmount).FirstOrDefault()!;
38                        var pendingOrder = new Order(lastBidding.UserID, itemPendingOrder.CreatedByID, (int)OrderStatuses.Pending, lastBidding.BidAmount);
39
40                        itemService.CreateOrder(pendingOrder, itemPendingOrder);
41                    }
42                }
43
44                var pendingOrders = itemService.GetPendingOrders();
45
46                // notify seller and buyer for created order...
47
48                await Task.Delay(1000, stoppingToken);
49            }
50        }
51    }
52}

1using APPartment.Data.Server.Base;
2using APPartment.ORM.Framework.Declarations;
3using System;
4using System.Collections.Generic;
5using System.Linq;
6using System.Linq.Expressions;
7using System.Reflection;
8
9namespace APPartment.Infrastructure.Services.Base
10{
11    public class BaseCRUDService : MapperService
12    {
13        ...
14
15        public List<T> GetCollection<T>(Expression<Func<T, bool>> filter)
16            where T : class, IBaseObject, new()
17        {
18            var serverModelType = GetServerModelType<T>();
19
20            var getObjectsFilteredFunc = typeof(BaseFacade)
21                .GetMethods(BindingFlags.Public | BindingFlags.Instance)
22                .Where(x => x.Name.Equals(nameof(BaseFacade.GetObjects)))
23                .LastOrDefault()
24                .MakeGenericMethod(serverModelType);
25
26            var convertFilterFunc = typeof(MapperService)
27                .GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
28                .Where(x => x.Name.Equals(nameof(ConvertExpression)))
29                .FirstOrDefault()
30                .MakeGenericMethod(typeof(T), serverModelType);
31
32            var convertedFilter = convertFilterFunc.Invoke(this, new object[] { filter });
33
34            var serverModels = getObjectsFilteredFunc
35                .Invoke(BaseFacade, new object[] { convertedFilter });
36
37            var toViewModelFunc = typeof(MapperService)
38                .GetMethods(BindingFlags.Public | BindingFlags.Instance)
39                .Where(x => x.Name.Equals(nameof(MapperService.GetViewModelCollection)))
40                .FirstOrDefault()
41                .MakeGenericMethod(typeof(T), serverModelType);
42
43            var result = toViewModelFunc.Invoke(this, new object[] { serverModels }) as List<T>;
44
45            return result;
46        }

1using System;
2using System.Linq;
3using System.Linq.Expressions;
4using System.Reflection;
5using System.Data.SqlClient;
6using System.Collections.Generic;
7using APPartment.ORM.Framework.Tools;
8using APPartment.ORM.Framework.Declarations;
9using APPartment.ORM.Framework.Attributes;
10using System.ComponentModel.DataAnnotations.Schema;
11using APPartment.Common;
12using APPartment.ORM.Framework.Enums;
13
14namespace APPartment.ORM.Framework.Core
15{
16    public class DaoContext
17    {
18        private ExpressionToSql expressionToSql;
19
20        public DaoContext()
21        {
22            expressionToSql = new ExpressionToSql();
23        }
24
25        public T SelectGetObject<T>(T result, long ID)
26            where T : class, IBaseObject, new()
27        {
28            var table = GetTableName<T>();
29            var query = SqlQueryProvider.SelectBusinessObjectByID(table, ID.ToString());
30
31            using (SqlConnection conn = new SqlConnection(Configuration.DefaultConnectionString))
32            using (SqlCommand cmd = new SqlCommand(query, conn))
33            {
34                conn.Open();
35                var reader = cmd.ExecuteReader();
36
37                while (reader.Read())