asd

Tsi1.Api/Tsi1.Api/Controllers/CourseController.cs

@@ -56,6 +56,12 @@ namespace Tsi1.Api.Controllers
             var tenantId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "TenantId").Value);
             newCourse.TenantId = tenantId;
 
+            var bedeliaResult = await _bedeliaService.IsValidCourse(newCourse.Name);
+            if (bedeliaResult.HasError)
+            {
+                return BadRequest(bedeliaResult.Message);
+            }
+
             var result = await _courseService.Create(newCourse);
             if (result.HasError)
             {

Tsi1.Api/Tsi1.Api/Controllers/DataLoadController.cs

@@ -28,5 +28,46 @@ namespace Tsi1.Api.Controllers
 
             return Ok();
         }
+
+        [AllowAnonymous]
+        [HttpPost("LoadStudentsInBedelia")]
+        public async Task<IActionResult> LoadStudentsInBedelia()
+        {
+            try
+            {
+                var result = await _dataLoad.LoadStudentsInBedelia();
+                if (result.HasError)
+                {
+                    return BadRequest(result.Message);
+                }
+
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+
+            return Ok();
+        }
+
+        [AllowAnonymous]
+        [HttpPost("LoadCoursesInBedelia")]
+        public async Task<IActionResult> LoadCoursesInBedelia()
+        {
+            try
+            {
+                var result = await _dataLoad.LoadCoursesInBedelia();
+                if (result.HasError)
+                {
+                    return BadRequest(result.Message);
+                }
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+
+            return Ok();
+        }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/DataLoad/DataLoad.cs

-using System;
+using Microsoft.EntityFrameworkCore;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Tsi1.BusinessLayer.Dtos;
@@ -18,13 +20,15 @@ namespace Tsi1.BusinessLayer.DataLoad
         private readonly ICourseService _courseService;
         private readonly ISectionService _sectionService;
         private readonly ISectionItemService _sectionItemService;
+        private readonly IBedeliaService _bedeliaService;
 
         public DataLoad(Tsi1Context context,
             ITenantService tenantService,
             IUserService userService,
             ICourseService courseService,
             ISectionService sectionService,
-            ISectionItemService sectionItemService)
+            ISectionItemService sectionItemService,
+            IBedeliaService bedeliaService)
         {
             _context = context;
             _tenantService = tenantService;
@@ -32,6 +36,34 @@ namespace Tsi1.BusinessLayer.DataLoad
             _courseService = courseService;
             _sectionService = sectionService;
             _sectionItemService = sectionItemService;
+            _bedeliaService = bedeliaService;
+        }
+
+        public async Task<ServiceResult<bool>> LoadStudentsInBedelia()
+        {
+            var users = await (from u in _context.Users
+                         join s in _context.Students
+                            on u.StudentId equals s.Id
+                         select new UserCreateBedeliaDto
+                         {
+                             IdentityCard = s.IdentityCard,
+                             Name = string.Join(" ", u.FirstName, u.LastName),
+                             Password = u.Password
+                         }).ToListAsync();
+
+            return await _bedeliaService.CreateUsers(users);
+        }
+
+        public async Task<ServiceResult<bool>> LoadCoursesInBedelia()
+        {
+            var courses = await _context.Courses.Select(x => 
+                new CourseCreateBedeliaDto()
+                {
+                    Name = x.Name
+                })
+                .ToListAsync();
+
+            return await _bedeliaService.CreateCourses(courses);
         }
 
         public async Task LoadDataAsync()

Tsi1.Api/Tsi1.BusinessLayer/DataLoad/IDataLoad.cs

@@ -2,11 +2,14 @@
 using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Helpers;
 
 namespace Tsi1.BusinessLayer.DataLoad
 {
     public interface IDataLoad
     {
         Task LoadDataAsync();
+        Task<ServiceResult<bool>> LoadStudentsInBedelia();
+        Task<ServiceResult<bool>> LoadCoursesInBedelia();
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Dtos/CourseCreateBedeliaDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class CourseCreateBedeliaDto
+    {
+        public string Name { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Dtos/UserCreateBedeliaDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class UserCreateBedeliaDto
+    {
+        public string IdentityCard { get; set; }
+        public string Name { get; set; }
+        public string Password { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IBedeliaService.cs

@@ -10,7 +10,9 @@ namespace Tsi1.BusinessLayer.Interfaces
     public interface IBedeliaService
     {
         Task<ServiceResult<bool>> IsValidUser(string identityCard);
-
         Task<ServiceResult<bool>> CloseRecord(string courseName, List<UserGradeDto> userGrades);
+        Task<ServiceResult<bool>> IsValidCourse(string courseName);
+        Task<ServiceResult<bool>> CreateUsers(List<UserCreateBedeliaDto> users);
+        Task<ServiceResult<bool>> CreateCourses(List<CourseCreateBedeliaDto> users);
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Services/BedeliaService.cs

@@ -57,5 +57,56 @@ namespace Tsi1.BusinessLayer.Services
 
             return result;
         }
+
+        public async Task<ServiceResult<bool>> IsValidCourse(string courseName)
+        {
+            var result = new ServiceResult<bool>();
+
+            var response = await _httpClient.GetAsync($"api/Courses/{courseName}");
+            if (response.StatusCode != HttpStatusCode.OK)
+            {
+                result.HasError = true;
+                var errorMessage = await response.Content.ReadAsStringAsync();
+                result.AddMessage(errorMessage);
+            }
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> CreateUsers(List<UserCreateBedeliaDto> users)
+        {
+            var result = new ServiceResult<bool>();
+
+            var jsonInString = JsonConvert.SerializeObject(users);
+            var model = new StringContent(jsonInString, Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync("api/Users", model);
+            if (response.StatusCode != HttpStatusCode.OK)
+            {
+                result.HasError = true;
+                var errorMessage = await response.Content.ReadAsStringAsync();
+                result.AddMessage(errorMessage);
+            }
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> CreateCourses(List<CourseCreateBedeliaDto> courses)
+        {
+            var result = new ServiceResult<bool>();
+
+            var jsonInString = JsonConvert.SerializeObject(courses);
+            var model = new StringContent(jsonInString, Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync("api/Courses", model);
+            if (response.StatusCode != HttpStatusCode.OK)
+            {
+                result.HasError = true;
+                var errorMessage = await response.Content.ReadAsStringAsync();
+                result.AddMessage(errorMessage);
+            }
+
+            return result;
+        }
     }
 }