Polikar/constructdemo
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Add project files.

Browse Source
This commit is contained in:
Sabi Polikar
2025-05-01 15:18:30 +03:00
parent e058ab8015
commit 774d695414
3094 changed files with 1336814 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
ConstructorAppUI/Controllers/AdminLayoutController.cs Normal file
View File

@@ -0,0 +1,12 @@
using Microsoft.AspNetCore.Mvc;
namespace ConstructorAppUI.Controllers
{
public class AdminLayoutController : Controller
{
public IActionResult Index()
{
return View();
}
}
}

62
ConstructorAppUI/Controllers/CompanyInfoController.cs Normal file
View File

@@ -0,0 +1,62 @@
using ConstructorAppUI.Dtos.CompanyInfoDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class CompanyInfoController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public CompanyInfoController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/CompanyInfo");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultCompanyInfoDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateCompanyInfo(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/CompanyInfo/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateCompanyInfoDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateCompanyInfo(UpdateCompanyInfoDto updateCompanyInfoDto)
{
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(updateCompanyInfoDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/CompanyInfo/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
}
}

62
ConstructorAppUI/Controllers/CompanyInfoVideoController.cs Normal file
View File

@@ -0,0 +1,62 @@
using ConstructorAppUI.Dtos.CompanyInfoVideoDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class CompanyInfoVideoController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public CompanyInfoVideoController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/CompanyInfoVideo");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultCompanyInfoVideoDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateCompanyInfoVideo(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/CompanyInfoVideo/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateCompanyInfoVideoDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateCompanyInfoVideo(UpdateCompanyInfoVideoDto updateCompanyInfoVideoDto)
{
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(updateCompanyInfoVideoDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/CompanyInfoVideo/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
}
}

38
ConstructorAppUI/Controllers/ContactUsController.cs Normal file
View File

@@ -0,0 +1,38 @@
using ConstructorAppUI.Dtos.ContactUsDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
namespace ConstructorAppUI.Controllers
{
public class ContactUsController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly string _apiBaseUrl;
public ContactUsController(IHttpClientFactory httpClientFactory, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/ContactUs");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultContactUsDto>>(jsonData);
return View(values);
}
return View();
}
public async Task<IActionResult> MarkAsRead(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/ContactUs/MarkAsRead/{id}");
return RedirectToAction("Index");
}
}
}

87
ConstructorAppUI/Controllers/DashboardController.cs Normal file
View File

@@ -0,0 +1,87 @@
using ConstructorAppUI.Dtos.ContactUsDtos;
using ConstructorAppUI.Dtos.ProjectDtos;
using ConstructorAppUI.Dtos.ReferenceDtos;
using ConstructorAppUI.Dtos.TestimonialDtos;
using ConstructorAppUI.ViewModels;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
namespace ConstructorAppUI.Controllers
{
public class DashboardController : Controller
{
private readonly string _signalRHubBaseUrl;
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public DashboardController(IConfiguration configuration, IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment)
{
_signalRHubBaseUrl = configuration["SignalRHubSettings:BaseUrl"];
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
//[Authorize(Roles = "Admin")]
public async Task<IActionResult> IndexAsync()
{
ViewBag.SignalRHubBaseUrl = _signalRHubBaseUrl;
ViewBag.ApiBaseUrl = _apiBaseUrl;
var client = _httpClientFactory.CreateClient();
// İletişim Talepleri için Listeyi Çek
var contactsResponse = await client.GetAsync($"{_apiBaseUrl}/api/ContactUs/CountAll");
var contacts = new List<ResultContactUsDto>();
var contactCount = 0;
if (contactsResponse.IsSuccessStatusCode)
{
var contactJsonData = await contactsResponse.Content.ReadAsStringAsync();
contactCount = JsonConvert.DeserializeObject<int>(contactJsonData);
}
// Projeler için Listeyi Çek
var projectResponse = await client.GetAsync($"{_apiBaseUrl}/api/Project/CountAll");
var projects = new List<ResultProjectDto>();
var projectCount = 0;
if (projectResponse.IsSuccessStatusCode)
{
var projectJsonData = await contactsResponse.Content.ReadAsStringAsync();
projectCount = JsonConvert.DeserializeObject<int>(projectJsonData);
}
// Reference için Listeyi Çek
var referenceResponse = await client.GetAsync($"{_apiBaseUrl}/api/Reference/CountAll");
var references = new List<ResultReferenceDto>();
var referenceCount = 0;
if (referenceResponse.IsSuccessStatusCode)
{
var referenceJsonData = await referenceResponse.Content.ReadAsStringAsync();
referenceCount = JsonConvert.DeserializeObject<int>(referenceJsonData);
}
// Testimonial için Listeyi Çek
var testimonialResponse = await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/CountAll");
var testimonials = new List<ResultTestimonialDto>();
var testimonialCount = 0;
if (testimonialResponse.IsSuccessStatusCode)
{
var testimonialJsonData = await referenceResponse.Content.ReadAsStringAsync();
testimonialCount = JsonConvert.DeserializeObject<int>(testimonialJsonData);
}
// ViewModel'i Doldur
var viewModel = new DashboardIndexViewModel
{
ContactUsCount = contactCount,
ProjectCount = projectCount,
ReferenceCount = referenceCount,
TestimonialCount = testimonialCount,
};
return View(viewModel);
}
}
}

107
ConstructorAppUI/Controllers/FooterController.cs Normal file
View File

@@ -0,0 +1,107 @@
using ConstructorAppUI.Dtos.FooterDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class FooterController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public FooterController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Footer");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultFooterDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateFooter(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Footer/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateFooterDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateFooter(UpdateFooterDto updateFooterDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Footer" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/Footer/{updateFooterDto.FooterID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateFooterDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// ImageUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.LogoUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.LogoUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateFooterDto.LogoUrl = $"/Images/{fileName}";
}
else
{
updateFooterDto.LogoUrl = existingSlider.LogoUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateFooterDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Footer/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateFooterDto);
}
}
}

107
ConstructorAppUI/Controllers/HomeBannerController.cs Normal file
View File

@@ -0,0 +1,107 @@
using ConstructorAppUI.Dtos.HomeBannerDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class HomeBannerController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public HomeBannerController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/HomeBanner");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultHomeBannerDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateHomeBanner(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/HomeBanner/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateHomeBannerDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateHomeBanner(UpdateHomeBannerDto updateHomeBannerDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Slider" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/HomeBanner/{updateHomeBannerDto.HomeBannerID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateHomeBannerDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// LogoUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.LogoUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.LogoUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateHomeBannerDto.LogoUrl = $"/Images/{fileName}";
}
else
{
updateHomeBannerDto.LogoUrl = existingSlider.LogoUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateHomeBannerDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/HomeBanner/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateHomeBannerDto);
}
}
}

23
ConstructorAppUI/Controllers/HomeController.cs Normal file
View File

@@ -0,0 +1,23 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace ConstructorAppUI.Controllers
{
[AllowAnonymous]
public class HomeController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly string _apiBaseUrl;
public HomeController(IHttpClientFactory httpClientFactory, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public IActionResult Index()
{
return View();
}
}
}

12
ConstructorAppUI/Controllers/HomeLayoutController.cs Normal file
View File

@@ -0,0 +1,12 @@
using Microsoft.AspNetCore.Mvc;
namespace ConstructorAppUI.Controllers
{
public class HomeLayoutController : Controller
{
public IActionResult Index()
{
return View();
}
}
}

74
ConstructorAppUI/Controllers/LoginController.cs Normal file
View File

@@ -0,0 +1,74 @@
using ConstructorApp.EntityLayer.Entities;
using ConstructorAppUI.ViewModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
namespace ConstructorAppUI.Controllers
{
[AllowAnonymous]
public class LoginController : Controller
{
private readonly SignInManager<AppUser> _signInManager;
private readonly UserManager<AppUser> _userManager;
public LoginController(SignInManager<AppUser> signInManager, UserManager<AppUser> userManager)
{
_signInManager = signInManager;
_userManager = userManager;
}
public IActionResult Index()
{
return View();
}
[HttpPost]
public async Task<IActionResult> Index(LoginViewModel loginViewModel)
{
if (!ModelState.IsValid)
{
return View(loginViewModel);
}
var result = await _signInManager.PasswordSignInAsync(
loginViewModel.UserName,
loginViewModel.Password,
false,
true);
if (result.Succeeded)
{
var user = await _userManager.FindByNameAsync(loginViewModel.UserName);
if (user.EmailConfirmed)
{
var roles = await _userManager.GetRolesAsync(user);
if (roles.Contains("Admin"))
{
return RedirectToAction("Index", "Dashboard");
}
}
else
{
ModelState.AddModelError(string.Empty, "E-posta adresiniz henüz onaylanmamış.");
}
}
else if (result.IsLockedOut)
{
ModelState.AddModelError(string.Empty, "Çok sayıda hatalı giriş yaptınız. Lütfen daha sonra tekrar deneyin.");
}
else
{
ModelState.AddModelError(string.Empty, "Kullanıcı adı veya şifre hatalı.");
}
return View(loginViewModel);
}
public async Task<IActionResult> Logout()
{
await _signInManager.SignOutAsync();
return RedirectToAction("Index", "Login");
}
}
}

250
ConstructorAppUI/Controllers/ProjectController.cs Normal file
View File

@@ -0,0 +1,250 @@
using ConstructorApp.DtoLayer.ProjectGalleryDto;
using ConstructorAppUI.Dtos.ProjectDtos;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Newtonsoft.Json;
using System.ComponentModel.DataAnnotations;
using System.Reflection;
using System.Text;
using static ConstructorApp.EntityLayer.Entities.Project;
namespace ConstructorAppUI.Controllers
{
public class ProjectController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public ProjectController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Project");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultProjectDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public IActionResult CreateProject()
{
return View();
}
[HttpPost]
public async Task<IActionResult> CreateProject(CreateProjectDto createProjectDto, IFormFile CoverFile, IFormFile FloorPlanFile)
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images");
// Klasör kontrolü
if (!Directory.Exists(imagePath))
{
Directory.CreateDirectory(imagePath);
}
// Cover Görseli Kaydet
if (CoverFile != null && CoverFile.Length > 0)
{
var coverPath = Path.Combine(imagePath, CoverFile.FileName);
using (var stream = new FileStream(coverPath, FileMode.Create))
{
await CoverFile.CopyToAsync(stream);
}
createProjectDto.CoverUrl = "/Images/" + CoverFile.FileName;
}
// FloorPlan Görseli Kaydet
if (FloorPlanFile != null && FloorPlanFile.Length > 0)
{
var floorPath = Path.Combine(imagePath, FloorPlanFile.FileName);
using (var stream = new FileStream(floorPath, FileMode.Create))
{
await FloorPlanFile.CopyToAsync(stream);
}
createProjectDto.FloorPlanUrl = "/Images/" + FloorPlanFile.FileName;
}
// API'ye gönder
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(createProjectDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PostAsync($"{_apiBaseUrl}/api/Project", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateProject(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Project/{id}");
ViewBag.StatusList = Enum.GetValues(typeof(ProjectStatus))
.Cast<ProjectStatus>()
.Select(e => new SelectListItem
{
Value = ((int)e).ToString(), // INT OLARAK VALUE
Text = e.GetType()
.GetMember(e.ToString())
.First()
.GetCustomAttribute<DisplayAttribute>()?.Name ?? e.ToString()
}).ToList();
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateProjectDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateProject(UpdateProjectDto updateProjectDto, IFormFile CoverFile, IFormFile FloorPlanFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Project" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/Project/{updateProjectDto.ProjectID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateProjectDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// CoverUrl işlemi
if (CoverFile != null && CoverFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.CoverUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.CoverUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(CoverFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await CoverFile.CopyToAsync(stream);
}
updateProjectDto.CoverUrl = $"/Images/{fileName}";
}
else
{
updateProjectDto.CoverUrl = existingSlider.CoverUrl;
}
// FloorPlanUrl işlemi
if (FloorPlanFile != null && FloorPlanFile.Length > 0)
{
if (!string.IsNullOrEmpty(existingSlider.FloorPlanUrl))
{
var oldFloorPlanPath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.FloorPlanUrl.TrimStart('/'));
if (System.IO.File.Exists(oldFloorPlanPath))
{
System.IO.File.Delete(oldFloorPlanPath);
}
}
var floorPlanFileName = Path.GetFileName(FloorPlanFile.FileName);
var floorPlanPath = Path.Combine(imagesPath, floorPlanFileName);
using (var stream = new FileStream(floorPlanPath, FileMode.Create))
{
await FloorPlanFile.CopyToAsync(stream);
}
updateProjectDto.FloorPlanUrl = $"/Images/{floorPlanFileName}";
}
else
{
updateProjectDto.FloorPlanUrl = existingSlider.FloorPlanUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateProjectDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Project/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateProjectDto);
}
public async Task<IActionResult> ProjectStatusActive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/Project/ProjectStatusActive/{id}");
return RedirectToAction("Index");
}
public async Task<IActionResult> ProjectStatusPassive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/Project/ProjectStatusPassive/{id}");
return RedirectToAction("Index");
}
[AllowAnonymous]
[Route("projeler/{slug}")]
public async Task<IActionResult> Detail(string slug)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Project/GetBySlug/{slug}");
if (!responseMessage.IsSuccessStatusCode)
{
return NotFound();
}
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var value = JsonConvert.DeserializeObject<ResultProjectDto>(jsonData);
// Görselleri çek
var imageResponse = await client.GetAsync($"{_apiBaseUrl}/api/ProjectImage/GetByProjectId/{value.ProjectID}");
if (imageResponse.IsSuccessStatusCode)
{
var imageJson = await imageResponse.Content.ReadAsStringAsync();
var imageList = JsonConvert.DeserializeObject<List<ResultProjectGalleryDto>>(imageJson);
value.ImageUrls = imageList.Select(x => x.ImageUrl).ToList();
}
return View(value);
}
}
}

122
ConstructorAppUI/Controllers/ProjectGalleryController.cs Normal file
View File

@@ -0,0 +1,122 @@
using ConstructorAppUI.Dtos.ProjectDtos;
using ConstructorAppUI.Dtos.ProjectGalleryDtos;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class ProjectGalleryController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public ProjectGalleryController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index(int? projectId)
{
var client = _httpClientFactory.CreateClient();
// Tüm galerileri al
var galleryResponse = await client.GetAsync($"{_apiBaseUrl}/api/ProjectGallery/GetByProjectId/{projectId}");
var galleryValues = new List<ResultProjectGalleryDto>();
if (galleryResponse.IsSuccessStatusCode)
{
var jsonData = await galleryResponse.Content.ReadAsStringAsync();
galleryValues = JsonConvert.DeserializeObject<List<ResultProjectGalleryDto>>(jsonData);
}
// Tüm projeleri al (dropdown için)
var projectResponse = await client.GetAsync($"{_apiBaseUrl}/api/Project");
if (projectResponse.IsSuccessStatusCode)
{
var projectJson = await projectResponse.Content.ReadAsStringAsync();
var projectValues = JsonConvert.DeserializeObject<List<ResultProjectDto>>(projectJson);
ViewBag.ProjectList = new SelectList(projectValues, "ProjectID", "Title");
}
// BaseUrl'i View'a aktar
ViewData["ApiBaseUrl"] = _apiBaseUrl;
return View(galleryValues);
}
public async Task<IActionResult> GetByProjectId(int projectId)
{
var client = _httpClientFactory.CreateClient();
var response = await client.GetAsync($"{_apiBaseUrl}/api/ProjectGallery/GetByProjectId/{projectId}");
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject<List<ResultProjectGalleryDto>>(json);
return Json(data);
}
return Json(new List<ResultProjectGalleryDto>());
}
[HttpGet]
public async Task<IActionResult> CreateProjectGalleryAsync()
{
var client = _httpClientFactory.CreateClient();
var response = await client.GetAsync($"{_apiBaseUrl}/api/Project");
if (!response.IsSuccessStatusCode)
{
return View(); // veya hata sayfası
}
var json = await response.Content.ReadAsStringAsync();
var projects = JsonConvert.DeserializeObject<List<ResultProjectDto>>(json);
ViewBag.ProjectList = new SelectList(projects, "ProjectID", "Title");
return View();
}
[HttpPost]
public async Task<IActionResult> CreateProjectGallery(int projectId, List<IFormFile> GalleryFiles)
{
if (GalleryFiles == null || !GalleryFiles.Any())
{
return BadRequest("Hiç görsel seçilmedi.");
}
foreach (var file in GalleryFiles)
{
// Görseli sunucuda kaydet
var imagePath = Path.Combine(_webHostEnvironment.WebRootPath, "Images", file.FileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await file.CopyToAsync(stream);
}
// API'ye gönderilecek DTO
var dto = new CreateProjectGalleryDto
{
ProjectID = projectId,
ImageUrl = "/Images/" + file.FileName
};
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(dto);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
await client.PostAsync($"{_apiBaseUrl}/api/ProjectGallery", content);
}
return RedirectToAction("Index", "ProjectGallery", new { id = projectId });
}
}
}

193
ConstructorAppUI/Controllers/ReferenceController.cs Normal file
View File

@@ -0,0 +1,193 @@
using ConstructorAppUI.Dtos.ReferenceDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class ReferenceController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public ReferenceController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Reference");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultReferenceDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public IActionResult CreateReference()
{
return View();
}
[HttpPost]
public async Task<IActionResult> CreateReference(CreateReferenceDto createReferenceDto, IFormFile ImageFile)
{
if (ImageFile != null)
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images");
// Klasör mevcut değilse oluştur
if (!Directory.Exists(imagePath))
{
Directory.CreateDirectory(imagePath);
}
var filePath = Path.Combine(imagePath, ImageFile.FileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
createReferenceDto.LogoUrl = "/Images/" + ImageFile.FileName;
}
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(createReferenceDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PostAsync($"{_apiBaseUrl}/api/Reference", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateReference(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Reference/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateReferenceDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateReference(UpdateReferenceDto updateReferenceDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Slider" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/Reference/{updateReferenceDto.ReferenceID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateReferenceDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// ImageUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.LogoUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.LogoUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateReferenceDto.LogoUrl = $"/Images/{fileName}";
}
else
{
updateReferenceDto.LogoUrl = existingSlider.LogoUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateReferenceDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Reference/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateReferenceDto);
}
[HttpGet]
public async Task<IActionResult> DeleteReferenceConfirmation(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Reference/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var reference = JsonConvert.DeserializeObject<UpdateReferenceDto>(jsonData);
return View(reference);
}
return View("Error");
}
[HttpPost]
public async Task<IActionResult> DeleteReference(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Reference/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var reference = JsonConvert.DeserializeObject<UpdateReferenceDto>(jsonData);
if (!string.IsNullOrEmpty(reference.LogoUrl))
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images", Path.GetFileName(reference.LogoUrl));
// Görselin gerçekten var olup olmadığını kontrol et
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Delete(imagePath); // Sadece görsel dosyasını sil
}
}
var deleteResponse = await client.DeleteAsync($"{_apiBaseUrl}/api/Reference/{id}");
if (deleteResponse.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View("Error");
}
}
}

76
ConstructorAppUI/Controllers/ServiceController.cs Normal file
View File

@@ -0,0 +1,76 @@
using ConstructorAppUI.Dtos.ServiceDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class ServiceController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public ServiceController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Service");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultServiceDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateService(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Service/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateServiceDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateService(UpdateServiceDto updateServiceDto)
{
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(updateServiceDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Service/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
public async Task<IActionResult> ServiceStatusActive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/Service/ServiceStatusActive/{id}");
return RedirectToAction("Index");
}
public async Task<IActionResult> ServiceStatusPassive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/Service/ServiceStatusPassive/{id}");
return RedirectToAction("Index");
}
}
}

193
ConstructorAppUI/Controllers/SliderController.cs Normal file
View File

@@ -0,0 +1,193 @@
using ConstructorAppUI.Dtos.SliderDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class SliderController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public SliderController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Slider");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultSliderDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public IActionResult CreateSlider()
{
return View();
}
[HttpPost]
public async Task<IActionResult> CreateSlider(CreateSliderDto createSliderDto, IFormFile ImageFile)
{
if (ImageFile != null)
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images");
// Klasör mevcut değilse oluştur
if (!Directory.Exists(imagePath))
{
Directory.CreateDirectory(imagePath);
}
var filePath = Path.Combine(imagePath, ImageFile.FileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
createSliderDto.ImageUrl = "/Images/" + ImageFile.FileName;
}
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(createSliderDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PostAsync($"{_apiBaseUrl}/api/Slider", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateSlider(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Slider/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateSliderDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateSlider(UpdateSliderDto updateSliderDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Slider" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/Slider/{updateSliderDto.SliderID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateSliderDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// ImageUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.ImageUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.ImageUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateSliderDto.ImageUrl = $"/Images/{fileName}";
}
else
{
updateSliderDto.ImageUrl = existingSlider.ImageUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateSliderDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Slider/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateSliderDto);
}
[HttpGet]
public async Task<IActionResult> DeleteSliderConfirmation(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Slider/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var slider = JsonConvert.DeserializeObject<UpdateSliderDto>(jsonData);
return View(slider);
}
return View("Error");
}
[HttpPost]
public async Task<IActionResult> DeleteSlider(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Slider/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var slider = JsonConvert.DeserializeObject<UpdateSliderDto>(jsonData);
if (!string.IsNullOrEmpty(slider.ImageUrl))
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images", Path.GetFileName(slider.ImageUrl));
// Görselin gerçekten var olup olmadığını kontrol et
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Delete(imagePath); // Sadece görsel dosyasını sil
}
}
var deleteResponse = await client.DeleteAsync($"{_apiBaseUrl}/api/Slider/{id}");
if (deleteResponse.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View("Error");
}
}
}

193
ConstructorAppUI/Controllers/TeamController.cs Normal file
View File

@@ -0,0 +1,193 @@
using ConstructorAppUI.Dtos.TeamDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class TeamController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public TeamController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Team");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultTeamDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public IActionResult CreateTeam()
{
return View();
}
[HttpPost]
public async Task<IActionResult> CreateTeam(CreateTeamDto createTeamDto, IFormFile ImageFile)
{
if (ImageFile != null)
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images");
// Klasör mevcut değilse oluştur
if (!Directory.Exists(imagePath))
{
Directory.CreateDirectory(imagePath);
}
var filePath = Path.Combine(imagePath, ImageFile.FileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
createTeamDto.ImageUrl = "/Images/" + ImageFile.FileName;
}
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(createTeamDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PostAsync($"{_apiBaseUrl}/api/Team", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateTeam(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Team/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateTeamDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateTeam(UpdateTeamDto updateTeamDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Team" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/Team/{updateTeamDto.TeamID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateTeamDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// ImageUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.ImageUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.ImageUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateTeamDto.ImageUrl = $"/Images/{fileName}";
}
else
{
updateTeamDto.ImageUrl = existingSlider.ImageUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateTeamDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Team/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateTeamDto);
}
[HttpGet]
public async Task<IActionResult> DeleteTeamConfirmation(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Team/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var slider = JsonConvert.DeserializeObject<UpdateTeamDto>(jsonData);
return View(slider);
}
return View("Error");
}
[HttpPost]
public async Task<IActionResult> DeleteTeam(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Team/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var slider = JsonConvert.DeserializeObject<UpdateTeamDto>(jsonData);
if (!string.IsNullOrEmpty(slider.ImageUrl))
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images", Path.GetFileName(slider.ImageUrl));
// Görselin gerçekten var olup olmadığını kontrol et
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Delete(imagePath); // Sadece görsel dosyasını sil
}
}
var deleteResponse = await client.DeleteAsync($"{_apiBaseUrl}/api/Team/{id}");
if (deleteResponse.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View("Error");
}
}
}

210
ConstructorAppUI/Controllers/TestimonialController.cs Normal file
View File

@@ -0,0 +1,210 @@
using ConstructorApp.EntityLayer.Entities;
using ConstructorAppUI.Dtos.TestimonialDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class TestimonialController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public TestimonialController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Testimonial");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultTestimonialDto>>(jsonData);
// Pending olan öğeleri en üste getirmek için sıralama yapılıyor
var sortedValues = values.OrderByDescending(t => t.Status == TestimonialStatus.Pending).ToList();
return View(sortedValues);
}
return View();
}
[HttpGet]
public IActionResult CreateTestimonial()
{
return View();
}
[HttpPost]
public async Task<IActionResult> CreateTestimonial(CreateTestimonialDto createTestimonialDto, IFormFile ImageFile)
{
if (ImageFile != null)
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images");
// Klasör mevcut değilse oluştur
if (!Directory.Exists(imagePath))
{
Directory.CreateDirectory(imagePath);
}
var filePath = Path.Combine(imagePath, ImageFile.FileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
createTestimonialDto.ImageUrl = "/Images/" + ImageFile.FileName;
}
var client = _httpClientFactory.CreateClient();
var jsonData = JsonConvert.SerializeObject(createTestimonialDto);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PostAsync($"{_apiBaseUrl}/api/Testimonial", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateTestimonial(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateTestimonialDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateTestimonial(UpdateTestimonialDto updateTestimonialDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "Testimonial" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/{updateTestimonialDto.TestimonialID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateTestimonialDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// ImageUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.ImageUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.ImageUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateTestimonialDto.ImageUrl = $"/Images/{fileName}";
}
else
{
updateTestimonialDto.ImageUrl = existingSlider.ImageUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateTestimonialDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/Testimonial/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateTestimonialDto);
}
[HttpGet]
public async Task<IActionResult> DeleteTestimonialConfirmation(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var slider = JsonConvert.DeserializeObject<UpdateTestimonialDto>(jsonData);
return View(slider);
}
return View("Error");
}
[HttpPost]
public async Task<IActionResult> DeleteTestimonial(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var slider = JsonConvert.DeserializeObject<UpdateTestimonialDto>(jsonData);
if (!string.IsNullOrEmpty(slider.ImageUrl))
{
var imagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/Images", Path.GetFileName(slider.ImageUrl));
// Görselin gerçekten var olup olmadığını kontrol et
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Delete(imagePath); // Sadece görsel dosyasını sil
}
}
var deleteResponse = await client.DeleteAsync($"{_apiBaseUrl}/api/Testimonial/{id}");
if (deleteResponse.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View("Error");
}
public async Task<IActionResult> TestimonialStatusActive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/TestimonialStatusActive/{id}");
return RedirectToAction("Index");
}
public async Task<IActionResult> TestimonialStatusPassive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/Testimonial/TestimonialStatusPassive/{id}");
return RedirectToAction("Index");
}
}
}

80
ConstructorAppUI/Controllers/UserProfileController.cs Normal file
View File

@@ -0,0 +1,80 @@
using ConstructorApp.DtoLayer.AppUserDto;
using ConstructorApp.EntityLayer.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
namespace ConstructorAppUI.Controllers
{
public class UserProfileController : Controller
{
private readonly UserManager<AppUser> _userManager;
private readonly SignInManager<AppUser> _signInManager;
public UserProfileController(UserManager<AppUser> userManager, SignInManager<AppUser> signInManager)
{
_userManager = userManager;
_signInManager = signInManager;
}
public async Task<IActionResult> IndexAsync()
{
var value = await _userManager.FindByNameAsync(User.Identity.Name);
AppUserEditDto appUserEditDto = new AppUserEditDto()
{
UserName = value.UserName,
CurrentPassword = "", // Boş bırakılabilir, formda doldurulacak
Password = "",
ConfirmPassword = ""
};
return View(appUserEditDto);
}
[HttpPost]
public async Task<IActionResult> Index(AppUserEditDto appUserEditDto)
{
if (!ModelState.IsValid)
return View(appUserEditDto);
var user = await _userManager.FindByNameAsync(User.Identity.Name);
// Şifre değiştirme talebi varsa
if (!string.IsNullOrWhiteSpace(appUserEditDto.Password))
{
// Mevcut şifre boşsa veya doğrulanamazsa hata dön
var passwordCheck = await _userManager.CheckPasswordAsync(user, appUserEditDto.CurrentPassword ?? "");
if (!passwordCheck)
{
ModelState.AddModelError(nameof(appUserEditDto.CurrentPassword), "Mevcut şifre yanlış.");
return View(appUserEditDto);
}
var result = await _userManager.ChangePasswordAsync(user, appUserEditDto.CurrentPassword, appUserEditDto.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
ModelState.AddModelError(string.Empty, error.Description);
return View(appUserEditDto);
}
// Şifre değiştikten sonra kullanıcıyı yeniden giriş yaptır
await _signInManager.SignOutAsync();
return RedirectToAction("Index", "Login");
}
// Şifre değişmemişse sadece kullanıcı adını güncelle (istersen burada kontrol koyabilirsin)
if (user.UserName != appUserEditDto.UserName)
{
user.UserName = appUserEditDto.UserName;
var updateResult = await _userManager.UpdateAsync(user);
if (!updateResult.Succeeded)
{
foreach (var error in updateResult.Errors)
ModelState.AddModelError(string.Empty, error.Description);
return View(appUserEditDto);
}
}
return RedirectToAction("Index", "Dashboard");
}
}
}

121
ConstructorAppUI/Controllers/WorkProcessController.cs Normal file
View File

@@ -0,0 +1,121 @@
using ConstructorAppUI.Dtos.WorkProcessDtos;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Text;
namespace ConstructorAppUI.Controllers
{
public class WorkProcessController : Controller
{
private readonly IHttpClientFactory _httpClientFactory;
private readonly IWebHostEnvironment _webHostEnvironment;
private readonly string _apiBaseUrl;
public WorkProcessController(IHttpClientFactory httpClientFactory, IWebHostEnvironment webHostEnvironment, IConfiguration configuration)
{
_httpClientFactory = httpClientFactory;
_webHostEnvironment = webHostEnvironment;
_apiBaseUrl = configuration["ApiSettings:BaseUrl"];
}
public async Task<IActionResult> Index()
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/WorkProcess");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<List<ResultWorkProcessDto>>(jsonData);
return View(values);
}
return View();
}
[HttpGet]
public async Task<IActionResult> UpdateWorkProcess(int id)
{
var client = _httpClientFactory.CreateClient();
var responseMessage = await client.GetAsync($"{_apiBaseUrl}/api/WorkProcess/{id}");
if (responseMessage.IsSuccessStatusCode)
{
var jsonData = await responseMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject<UpdateWorkProcessDto>(jsonData);
return View(values);
}
return View();
}
[HttpPost]
public async Task<IActionResult> UpdateWorkProcess(UpdateWorkProcessDto updateWorkProcessDto, IFormFile ImageFile)
{
var client = _httpClientFactory.CreateClient();
// Mevcut "WorkProcess" verisini al
var existingSliderResponse = await client.GetAsync($"{_apiBaseUrl}/api/WorkProcess/{updateWorkProcessDto.WorkProcessID}");
if (existingSliderResponse.IsSuccessStatusCode)
{
var existingJsonData = await existingSliderResponse.Content.ReadAsStringAsync();
var existingSlider = JsonConvert.DeserializeObject<UpdateWorkProcessDto>(existingJsonData);
// Görseller için "wwwroot/Images" klasörünün varlığını kontrol et
var imagesPath = Path.Combine(_webHostEnvironment.WebRootPath, "Images");
if (!Directory.Exists(imagesPath))
{
Directory.CreateDirectory(imagesPath);
}
// ImageUrl için işlem
if (ImageFile != null && ImageFile.Length > 0)
{
// Eski görseli sil
if (!string.IsNullOrEmpty(existingSlider.ImageUrl))
{
var oldImagePath = Path.Combine(_webHostEnvironment.WebRootPath, existingSlider.ImageUrl.TrimStart('/'));
if (System.IO.File.Exists(oldImagePath))
{
System.IO.File.Delete(oldImagePath);
}
}
// Yeni görseli yükle
var fileName = Path.GetFileName(ImageFile.FileName);
var imagePath = Path.Combine(imagesPath, fileName);
using (var stream = new FileStream(imagePath, FileMode.Create))
{
await ImageFile.CopyToAsync(stream);
}
updateWorkProcessDto.ImageUrl = $"/Images/{fileName}";
}
else
{
updateWorkProcessDto.ImageUrl = existingSlider.ImageUrl;
}
// API'ye güncelleme isteği gönder
var updatedJsonData = JsonConvert.SerializeObject(updateWorkProcessDto);
StringContent stringContent = new StringContent(updatedJsonData, Encoding.UTF8, "application/json");
var responseMessage = await client.PutAsync($"{_apiBaseUrl}/api/WorkProcess/", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
}
return View(updateWorkProcessDto);
}
public async Task<IActionResult> ServiceStatusActive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/WorkProcess/ServiceStatusActive/{id}");
return RedirectToAction("Index");
}
public async Task<IActionResult> ServiceStatusPassive(int id)
{
var client = _httpClientFactory.CreateClient();
await client.GetAsync($"{_apiBaseUrl}/api/WorkProcess/ServiceStatusPassive/{id}");
return RedirectToAction("Index");
}
}
}