ProductAPI

1
namespace ProductAPI.Service.Implementations
2
{
3
    public class CategoryService : BaseService<CategoryService, CategoryDTO>, ICategoryService
4
    {
5
        private readonly ICategoryRepository _categoryRep;
6
        private readonly IImageAccessorService _imageAccessorSer;
7
        public CategoryService(ICategoryRepository categoryRep, IImageAccessorService imageAccessorSer, IMapper mapper, ILogger<CategoryService> logger) 
8
            : base(mapper, logger, new()) 
9
        {
10
            _categoryRep = categoryRep;
11
            _imageAccessorSer = imageAccessorSer;
12
        }
13

14
        #region Create
15
        /// <summary>
16
        /// Создание категории.
17
        /// </summary>
18
        /// <param name="createModel"></param>
19
        /// <returns>Базовый ответ.</returns>
20
        public async Task<IBaseResponse<CategoryDTO>> CreateServiceAsync(CreateCategoryDTO createModel)
21
        {
22
            _logger.LogInformation($"Создание категории. / method: CreateServiceAsync");
23
            if (await _categoryRep.GetByAsync(x => x.CategoryName == createModel.CategoryName) != null)
24
            {
25
                _logger.LogWarning("Категория с таким наименованием существует.");
26
                _baseResponse.DisplayMessage = "Категория с таким наименованием существует.";
27
                _baseResponse.Status = Status.ExistsName;
28
                return _baseResponse!;
29
            }
30

31
            var category = _mapper.Map<Category>(createModel);
32

33
            if (createModel.Image != null)
34
            {
35
                var image = await _imageAccessorSer.AddImageAsync(createModel.Image).ConfigureAwait(true);
36
                if (image is null) _logger.LogInformation("Изображение не создано.");
37
                else
38
                {
39
                    _logger.LogInformation("Изображение создано.");
40
                    category.ImageUrl = image.Url;
41
                    category.ImageId = image.PublicId;
42
                };
43
            };
44

45
            var categoryRep = await _categoryRep.CreateAsync(category);
46
            if (categoryRep != null)
47
            {
48
                _logger.LogInformation("Категория создана.");
49
            }
50
            else
51
            {
52
                _logger.LogInformation("Категория не создана.");
53
                _baseResponse.DisplayMessage = "Категория не создана.";
54
                _baseResponse.Status = Status.NotCreate;
55
            }
56
            _baseResponse.Result = _mapper.Map<CategoryDTO>(categoryRep);
57
            _logger.LogInformation($"Ответ отправлен контролеру/method: CreateServiceAsync");
58
            return _baseResponse!;
59
        }
60
        #endregion
61

62
        #region Delete
63
        /// <summary>
64
        /// Удаление категории
65
        /// </summary>
66
        /// <param name="id"></param>
67
        /// <returns>Базовый ответ.</returns>
68
        public async Task<IBaseResponse<bool>> DeleteServiceAsync(int id)
69
        {
70
            _logger.LogInformation($"Удаление категории. / method: DeleteServiceAsync");
71
            var baseResponse = new BaseResponse<bool>();
72
            _logger.LogInformation($"Поиск категории по id: {id}. / method: DeleteServiceAsync");
73
            Category category = await _categoryRep.GetByAsync(x => x.CategoryId == id, true);
74
            if (category is null)
75
            {
76
                _logger.LogWarning($"Категория c id: {id} не найдена.");
77
                baseResponse.DisplayMessage = $"Категория c id: {id} не найдена.";
78
                baseResponse.Result = false;
79
                _logger.LogInformation($"Ответ отправлен контролеру (false)/ method: DeleteServiceAsync");
80
                return baseResponse;
81
            }
82

83
            if (category.ImageId != null) await _imageAccessorSer.DeleteImageAsync(category.ImageId);
84

85
            await _categoryRep.DeleteAsync(category);
86
            baseResponse.DisplayMessage = "Категория удалена.";
87
            baseResponse.Result = true;
88
            _logger.LogInformation($"Ответ отправлен контролеру (true)/ method: DeleteServiceAsync");
89
            return baseResponse;
90
        }
91
        #endregion
92

93
        #region GetById
94
        /// <summary>
95
        /// Вывод категории
96
        /// </summary>
97
        /// <param name="id"></param>
98
        /// <returns>Базовый ответ.</returns>
99
        public async Task<IBaseResponse<CategoryDTO>> GetByIdServiceAsync(int id)
100
        {
101
            _logger.LogInformation($"Поиск категории по id: {id}. / method: GetByIdServiceAsync");
102
            Category category = await _categoryRep.GetByAsync(x => x.CategoryId == id);
103
            if (category is null)
104
            {
105
                _logger.LogWarning($"Категория по id [{id}] не найдена");
106
                _baseResponse.DisplayMessage = $"Категория по id [{id}] не найдена";
107
                _baseResponse.Status = Status.NotFound;
108
            }
109
            else
110
            {
111
                _logger.LogInformation($"Вывод категории по id [{id}]");
112
            }
113
            _baseResponse.Result = _mapper.Map<CategoryDTO>(category);
114
            _logger.LogInformation($"Ответ отправлен контролеру/ method: GetByIdServiceAsync");
115
            return _baseResponse!;
116
        }
117
        #endregion
118

119
        #region Get
120
        /// <summary>
121
        /// Список категорий (возможно приминение фильра и поиска)
122
        /// </summary>
123
        /// <param name="filter"></param>
124
        /// <param name="search"></param>
125
        /// <returns>Базовый ответ.</returns>
126
        public async Task<IBaseResponse<List<CategoryDTO>>> GetServiceAsync(string? filter = null, string? search = null)
127
        {
128
            _logger.LogInformation($"Список категорий. / method: GetServiceAsync");
129
            var bResponse = new BaseResponse<List<CategoryDTO>>();
130
            IEnumerable<Category>? categorys = null;
131
            if (!string.IsNullOrEmpty(filter) && !string.IsNullOrEmpty(search))
132
            {
133
                var result = await FilterAndSearchAsync(categorys, filter, search);
134
                categorys = result.Item1;
135
                _baseResponse.DisplayMessage = result.Item2;
136
            }
137
            if (!string.IsNullOrEmpty(filter) && string.IsNullOrEmpty(search))
138
            {
139
                var result = await FilterAndSearchAsync(categorys, filter);
140
                categorys = result.Item1;
141
                _baseResponse.DisplayMessage = result.Item2;
142
            }
143
            if (string.IsNullOrEmpty(filter) && string.IsNullOrEmpty(search))
144
            {
145
                categorys = await _categoryRep.GetAsync(search: search);
146
            }
147
            if (categorys is null)
148
            {
149
                _logger.LogInformation("Список категорий пуст.");
150
                _baseResponse.DisplayMessage = "Список категорий пуст.";
151
            }
152
            else
153
            {
154
                _logger.LogInformation("Список категорий.");
155
                IEnumerable<CategoryDTO> listCategorys = _mapper.Map<IEnumerable<CategoryDTO>>(categorys);
156
                bResponse.Result = listCategorys.ToList();
157
            }
158
            _logger.LogInformation($"Ответ отправлен контролеру/ method: GetServiceAsync");
159
            return bResponse;
160
        }
161
        #endregion
162

163
        #region Update
164
        /// <summary>
165
        /// Обновление категории.
166
        /// </summary>
167
        /// <param name="updateModel"></param>
168
        /// <returns>Базовый ответ.</returns>
169
        /// <exception cref="NullReferenceException"></exception>
170
        public async Task<IBaseResponse<CategoryDTO>> UpdateServiceAsync(UpdateCategoryDTO updateModel)
171
        {
172
            _logger.LogInformation($"Обновление категории.");
173
            var carent = await _categoryRep.GetByAsync(x => x.CategoryId == updateModel.CategoryId);
174
            if (carent is null)
175
            {
176
                _logger.LogWarning("Попытка обновить объект, которого нет в хранилище.");
177
                _baseResponse.Status = Status.NotFound;
178
                _baseResponse.DisplayMessage = "Попытка обновить объект, которого нет в хранилище.";
179
            }
180
            else
181
            {
182
                var category = _mapper.Map<Category>(updateModel);
183
                if (updateModel.Image  != null)
184
                {
185
                    var image = await _imageAccessorSer.AddImageAsync(updateModel.Image, updateModel.ImageId).ConfigureAwait(true);
186
                    if (image is null) _logger.LogInformation("Изображение не создано.");
187
                    else
188
                    {
189
                        _logger.LogInformation("Изображение создано.");
190
                        category.ImageUrl = image.Url;
191
                        category.ImageId = image.PublicId;
192
                    };
193
                }
194
                var categoryRep = await _categoryRep.UpdateAsync(category, carent); ;
195
                _baseResponse.DisplayMessage = "Категория обновилась.";
196
                _baseResponse.Result = _mapper.Map<CategoryDTO>(categoryRep);
197
            }
198
            _logger.LogInformation($"Ответ отправлен контролеру/ method: UpdateServiceAsync");
199
            return _baseResponse!;
200
        }
201
        #endregion
202

203
        #region Filter
204
        /// <summary>
205
        /// Фильтр и поиск категорий по значению
206
        /// </summary>
207
        /// <param name="categorys"></param>
208
        /// <param name="filter"></param>
209
        /// <returns>Отфильтрованный список и сообщение</returns>
210
        private async Task<(IEnumerable<Category>?, string)> FilterAndSearchAsync(IEnumerable<Category>? categorys, string filter, string? search = null)
211
        {
212
            _logger.LogInformation($"Поиск категории по фильтру: {filter}. / method: FilterAsync");
213
            Uri? uri;
214
            if (Uri.TryCreate(filter, UriKind.Absolute, out uri)
215
                && (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps))
216
            {
217
                categorys = await _categoryRep.GetAsync(x => x.ImageUrl == uri.ToString(), search);
218

219
                if (categorys is null)
220
                    message = Message.FilterAndSearch(_logger, true, "категорий", filter, search);
221
                else
222
                    message = Message.FilterAndSearch(_logger, false, "категорий", filter, search);
223
            }
224
            else
225
            {
226
                categorys = await _categoryRep.GetAsync(x => x.CategoryName == filter, search);
227
                if (categorys is null)
228
                    message = Message.FilterAndSearch(_logger, true, "категорий", filter, search);
229
                else
230
                    message = Message.FilterAndSearch(_logger, false, "категорий", filter, search);
231
            }
232
            _logger.LogInformation($"Ответ отправлен GetServiceAsync/ method: FilterAsync");
233
            return (categorys, message);
234
        }
235
        #endregion
236
    }
237
}
238