Ignore:
Timestamp:
07/10/22 10:27:45 (2 years ago)
Author:
Danilo <danilo.najkov@…>
Branches:
master
Children:
a26f6a1
Parents:
cc4db18
Message:

reviews full feature

Location:
resTools_backend/backend
Files:
7 added
11 edited

Legend:

Unmodified
Added
Removed

  • resTools_backend/backend/Controllers/RestaurantsController.cs

    rcc4db18 r899b19d  
    2020    }
    2121
     22    /*
    2223    [Authorize]
    2324    [HttpPost()]
    … …  
    3031        return Ok();
    3132    }
     33    */
    3234
    3335    [HttpGet()]

  • resTools_backend/backend/Controllers/UsersController.cs

    rcc4db18 r899b19d  
    1313{
    1414    private readonly IUserService _userService = null;
     15    private readonly IRestaurantService _restaurantService = null;
    1516
    16     public UsersController(IUserService userService)
     17    public UsersController(IUserService userService, IRestaurantService restaurantService)
    1718    {
    1819        _userService = userService;
     20        _restaurantService = restaurantService;
    1921    }
    2022
    … …  
    4547    public async Task<AuthenticateResponse> Register(CreateUserRequest req)
    4648    {
    47         var response = await _userService.Register(req);
     49        bool isFirst = await _restaurantService.GetRestaurant() == null;
     50        var response = await _userService.Register(req, isFirst);
     51        if (isFirst)
     52        {
     53            await _restaurantService.CreateRestaurant("", response.Id);
     54        }
    4855        return response;
    4956    }

  • resTools_backend/backend/DTOs/AuthenticateResponse.cs

    rcc4db18 r899b19d  
    1313    [JsonProperty]
    1414    public string Token { get; set; }
     15    [JsonProperty]
     16    public bool IsAdmin { get; set; }
    1517}

  • resTools_backend/backend/DTOs/RestaurantResponse.cs

    rcc4db18 r899b19d  
    1414        public List<MenuItemResponse> Menu { get; set; }
    1515        [JsonProperty]
     16        public List<ReviewResponse> Reviews { get; set; }
     17        [JsonProperty]
     18        public double AverageReview { get; set; }
     19        [JsonProperty]
    1620        public string Base64Image { get; set; }
    1721    }

  • resTools_backend/backend/Data/DataContext.cs

    rcc4db18 r899b19d  
    6666        }
    6767
     68        private DbSet<Review> reviews;
     69        public DbSet<Review> Reviews
     70        {
     71            get
     72            {
     73                if (reviews == null)
     74                {
     75                    reviews = Set<Review>();
     76                }
     77
     78                return reviews;
     79            }
     80        }
     81
    6882
    6983        protected override void OnModelCreating(ModelBuilder modelBuilder)
    … …  
    89103            .WithOne(b => b.Restaurant);
    90104            modelBuilder.Entity<Restaurant>()
    91             .HasMany(p => p.Menu)
     105            .HasMany(p => p.Reviews)
    92106            .WithOne(b => b.Restaurant);
    93 
    94107
    95108            //
    … …  
    108121            .HasOne(p => p.Restaurant)
    109122            .WithMany(b => b.Menu);
     123
     124            //
     125            // Review
     126            //
     127            modelBuilder.Entity<Review>().Property(x => x.Id).IsRequired().ValueGeneratedOnAdd();
     128            modelBuilder.Entity<Review>()
     129            .HasOne(p => p.Restaurant)
     130            .WithMany(b => b.Reviews);
     131            modelBuilder.Entity<Review>()
     132            .HasOne(p => p.User);
    110133        }
    111134    }

  • resTools_backend/backend/Entities/Restaurant.cs

    rcc4db18 r899b19d  
    1010        public virtual ICollection<Reservation> Reservations { get; set; }
    1111        public virtual ICollection<MenuItem> Menu { get; set; }
     12        public virtual ICollection<Review> Reviews { get; set; }
    1213        public string Name { get; set; }
    1314        public string Address { get; set; }

  • resTools_backend/backend/Entities/User.cs

    rcc4db18 r899b19d  
    88    public string Email { get; set; }
    99    public string Password { get; set; }
    10     [JsonIgnore]
     10    public bool IsAdmin { get; set; }
    1111    public virtual Restaurant Restaurant { get; set; }
    1212}

  • resTools_backend/backend/Migrations/DataContextModelSnapshot.cs

    rcc4db18 r899b19d  
    131131                });
    132132
     133            modelBuilder.Entity("backend.Entities.Review", b =>
     134                {
     135                    b.Property<int>("Id")
     136                        .ValueGeneratedOnAdd()
     137                        .HasColumnType("integer");
     138
     139                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
     140
     141                    b.Property<DateTime>("CreatedAt")
     142                        .HasColumnType("timestamp with time zone");
     143
     144                    b.Property<string>("Description")
     145                        .IsRequired()
     146                        .HasColumnType("text");
     147
     148                    b.Property<int>("RestaurantId")
     149                        .HasColumnType("integer");
     150
     151                    b.Property<int>("Stars")
     152                        .HasColumnType("integer");
     153
     154                    b.Property<string>("Title")
     155                        .IsRequired()
     156                        .HasColumnType("text");
     157
     158                    b.Property<int>("UserId")
     159                        .HasColumnType("integer");
     160
     161                    b.HasKey("Id");
     162
     163                    b.HasIndex("RestaurantId");
     164
     165                    b.HasIndex("UserId");
     166
     167                    b.ToTable("Reviews");
     168                });
     169
    133170            modelBuilder.Entity("backend.Entities.User", b =>
    134171                {
    … …  
    142179                        .IsRequired()
    143180                        .HasColumnType("text");
     181
     182                    b.Property<bool>("IsAdmin")
     183                        .HasColumnType("boolean");
    144184
    145185                    b.Property<string>("Password")
    … …  
    183223                });
    184224
     225            modelBuilder.Entity("backend.Entities.Review", b =>
     226                {
     227                    b.HasOne("backend.Entities.Restaurant", "Restaurant")
     228                        .WithMany("Reviews")
     229                        .HasForeignKey("RestaurantId")
     230                        .OnDelete(DeleteBehavior.Cascade)
     231                        .IsRequired();
     232
     233                    b.HasOne("backend.Entities.User", "User")
     234                        .WithMany()
     235                        .HasForeignKey("UserId")
     236                        .OnDelete(DeleteBehavior.Cascade)
     237                        .IsRequired();
     238
     239                    b.Navigation("Restaurant");
     240
     241                    b.Navigation("User");
     242                });
     243
    185244            modelBuilder.Entity("backend.Entities.Restaurant", b =>
    186245                {
    … …  
    188247
    189248                    b.Navigation("Reservations");
     249
     250                    b.Navigation("Reviews");
    190251                });
    191252

  • resTools_backend/backend/Program.cs

    rcc4db18 r899b19d  
    4747builder.Services.AddScoped<IReservationService, ReservationService>();
    4848builder.Services.AddScoped<IMenuService, MenuService>();
     49builder.Services.AddScoped<IReviewService, ReviewService>();
    4950builder.Services.AddScoped<ISmsService, SmsService>();
    5051

  • resTools_backend/backend/Services/RestaurantService.cs

    rcc4db18 r899b19d  
    3232        {
    3333            RestaurantResponse res = await _context.Restoraunts
     34                .Include(x => x.Menu)
     35                .Include(x => x.Reviews).ThenInclude(x => x.User)
    3436                .Select(x => new RestaurantResponse()
    3537                {
    … …  
    4446                        Description = x.Description,
    4547                        Price = x.Price
    46                     }).ToList()
     48                    }).ToList(),
     49                    Reviews = x.Reviews.OrderByDescending(x => x.CreatedAt).Select(x => new ReviewResponse()
     50                    {
     51                        Id = x.Id,
     52                        Title = x.Title,
     53                        Description = x.Description,
     54                        Stars = x.Stars,
     55                        CreatedAt = x.CreatedAt,
     56                        Username = x.User == null ? "Anonymous" : x.User.Email
     57                    }).ToList(),
     58                    AverageReview = x.Reviews.Count>0 ? x.Reviews.Select(x => x.Stars).Average() : 0
    4759                })
    4860                .FirstOrDefaultAsync();

  • resTools_backend/backend/Services/UserService.cs

    rcc4db18 r899b19d  
    1515{
    1616    Task<AuthenticateResponse> Authenticate(AuthenticateRequest model);
    17     Task<AuthenticateResponse> Register(CreateUserRequest req);
     17    Task<AuthenticateResponse> Register(CreateUserRequest req, bool isFirst);
    1818    Task<User> GetById(int id);
    1919}
    … …  
    4040        var token = generateJwtToken(user);
    4141
    42         return new AuthenticateResponse { Email = user.Email, Id = user.Id, Token = token};
     42        return new AuthenticateResponse { Email = user.Email, Id = user.Id, Token = token, IsAdmin = user.IsAdmin};
    4343    }
    4444
    … …  
    4848    }
    4949
    50     public async Task<AuthenticateResponse> Register(CreateUserRequest req)
     50    public async Task<AuthenticateResponse> Register(CreateUserRequest req, bool isFirst)
    5151    {
    52         User user = new User() { Email = req.Email, Password = req.Password };
     52        User user = new User() { Email = req.Email, Password = req.Password, IsAdmin = isFirst };
    5353        await _context.Users.AddAsync(user);
    5454        await _context.SaveChangesAsync();
    5555        var token = generateJwtToken(user);
    56         return new AuthenticateResponse { Email = user.Email, Id = user.Id, Token = token };
     56        return new AuthenticateResponse { Email = user.Email, Id = user.Id, Token = token, IsAdmin = user.IsAdmin };
    5757    }
    5858
Note: See TracChangeset for help on using the changeset viewer.