public IActionResult GetAll()
{
BaseResponseDto <ChannelViewModel> responseDto = null;
ICollection <ChannelViewModel> result = null;
try
{
responseDto = _channel.GetAll();
}
catch (Exception e)
{
return(StatusCode(500, e));
}
if (responseDto.Status == 1 || responseDto.Status == 2)
{
return(Ok(responseDto.Message));
}
result = responseDto.Content.ToList();
return(Ok(result));
}
public async Task <BaseResponseDto <UserDto> > Login(AuthDto auth)
{
try
{
var user = await GetByEmailAsync(auth.Email);
BaseResponseDto <UserDto> userResponse = new BaseResponseDto <UserDto>();
if (user == null)
{
userResponse.Errors.Add("Email", "Enail is wrong");
return(userResponse);
}
var locker = CreateLockerInstance();
string decrpytPassword = locker.Decrypt(user.Password);
if (decrpytPassword != auth.Password)
{
userResponse.Errors.Add("Password", "Password is wrong");
return(userResponse);
}
JwtTokenHandler tokenHandler = new JwtTokenHandler();
var token = tokenHandler.CreateAccessToken(user);
user.AccessToken = token.AccessToken;
user.RefreshToken = token.RefreshToken;
user.RefreshTokenEndDate = token.Expiration.AddDays(1);
UserDto userDto = new UserDto(user.Id, user.FirstName, user.LastName, user.Address, user.AccessToken, user.Role);
userResponse.Data = userDto;
await _userRepository.UpdateAsync(user);
return(userResponse);
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult <string> > Get([FromRoute] string id)
{
if (string.IsNullOrEmpty(id))
{
return(BadRequest());
}
Guid _id = Guid.Parse(id);
BaseResponseDto <MovieDto> movie = await _movieService.GetAsync(_id);
if (!movie.HasError || movie.Data != null)
{
return(Ok(movie.Data));
}
else if (!movie.HasError || movie.Data == null)
{
return(NotFound());
}
else
{
return(BadRequest(movie.Errors));
}
}
public async Task <BaseResponseDto <ActiviteDto> > DeleteActivite(Guid IdAct)
{
BaseResponseDto <ActiviteDto> getResponse = new BaseResponseDto <ActiviteDto>();
try
{
if (IdAct != null)
{
Activite activite = await _activiteRepository.GetAsync(IdAct);
await _activiteRepository.DeleteAsync(activite);
}
else
{
getResponse.Errors.Add("Activity can't be delete.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
getResponse.Errors.Add(ex.Message);
}
return(getResponse);
}
public async Task <BaseResponseDto <Order> > Handle(GetOrderWithIdRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <Order> responseDto = new BaseResponseDto <Order>();
try
{
var redis = await _redisRepository.Get(request.Id.ToString());
if (redis != null)
{
responseDto.Data = redis;
return(responseDto);
}
var mssql = await _repository.Where(p => p.Id == request.Id)
.FirstOrDefaultAsync(cancellationToken);
if (mssql != null)
{
responseDto.Data = mssql;
await _redisRepository.Set(mssql);
}
else
{
responseDto.Errors.Add("No order for this Id was found");
responseDto.Data = null;
}
return(responseDto);
}
catch (Exception exception)
{
Console.WriteLine(exception);
responseDto.Errors.Add(exception.Message);
return(responseDto);
}
}
public async Task <ActionResult <string> > Get([FromRoute] string id)
{
if (string.IsNullOrEmpty(id))
{
return(BadRequest());
}
int _id = Convert.ToInt32(id);
BaseResponseDto <UserDto> user = await _userService.GetAsync(_id);
if (!user.HasError || user.Data != null)
{
return(Ok(user.Data));
}
else if (!user.HasError || user.Data == null)
{
return(NotFound());
}
else
{
return(BadRequest(user.Errors));
}
}
public async Task <BaseResponseDto <HoraireDto> > DeleteHoraire(Guid Id)
{
BaseResponseDto <HoraireDto> getResponse = new BaseResponseDto <HoraireDto>();
try
{
if (Id != null)
{
Horaire horaire = await _horaireRepository.GetAsync(Id);
await _horaireRepository.DeleteAsync(horaire);
}
else
{
getResponse.Errors.Add("Horaire can't be delete.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
getResponse.Errors.Add(ex.Message);
}
return(getResponse);
}
public async Task <BaseResponseDto <string> > UpdateProduct(Product product)
{
try
{
BaseResponseDto <string> productResponse = new BaseResponseDto <string>();
var result = new ProductValidator().Validate(product);
if (!result.IsValid)
{
foreach (var validationFailure in result.Errors)
{
productResponse.Errors.Add("Message", validationFailure.ErrorMessage);
}
return(productResponse);
}
await _repository.UpdateAsync(product);
productResponse.Data = "Updated product succesfully";
return(productResponse);
}
catch (Exception e)
{
return(CreateThrowMessage(e));
}
}
public async Task <BaseResponseDto <MemberDto> > AddMemberAsync([FromBody] AddMemberRequest addMemberRequest)
{
BaseResponseDto <MemberDto> response = await _mediator.Send(addMemberRequest);
return(response);
}
public async Task <BaseResponseDto <UserDto> > CreateUserAsync([FromBody] CreateUserRequest createUserRequest)
{
BaseResponseDto <UserDto> response = await _mediator.Send(createUserRequest);
return(response);
}
public void Play(ICommand command, out BaseResponseDto responseDto)
{
command.Execute(out responseDto);
}
public async Task <BaseResponseDto <bool> > UpdatePostAsync([FromBody] UpdatePostRequest updatePostRequest)
{
BaseResponseDto <bool> response = await _mediator.Send(updatePostRequest);
return(response);
}
public async Task <BaseResponseDto <ClassDto> > CreateClassAsync(CreateClassRequest createClassRequest)
{
BaseResponseDto <ClassDto> response = await _mediator.Send(createClassRequest);
return(response);
}
public BaseResponseDto Insert(ChannelInsertModel channelInsertModel)
{
BaseResponseDto responseDto = null;
if (channelInsertModel == null)
{
responseDto = new BaseResponseDto
{
Status = 1,
Message = "Faulthy channel info"
};
return(responseDto);
}
Channel existingChannel = null;
try
{
existingChannel = _uow
.GetRepository <Channel>()
.GetAll()
.FirstOrDefault(c =>
c.TopicId == channelInsertModel.TopicId &&
c.MentorId == channelInsertModel.MentorId);
}
catch (Exception e)
{
throw e;
}
if (existingChannel != null)
{
responseDto = new BaseResponseDto
{
Status = 2,
Message = "Channel already exist"
};
return(responseDto);
}
try
{
Channel newChannel = new Channel
{
ChannelId = Guid.NewGuid(),
TopicId = channelInsertModel.TopicId,
MentorId = channelInsertModel.MentorId,
IsDisable = false
};
_uow.GetRepository <Channel>().Insert(newChannel);
_uow.Commit();
}
catch (Exception e)
{
throw e;
}
responseDto = new BaseResponseDto
{
Status = 0,
Message = "Channel successfully inserted"
};
return(responseDto);
}
public BaseResponseDto InsertRating(RatingInsertModel ratingInsertModel)
{
BaseResponseDto responseDto = new BaseResponseDto
{
Status = 200,
Message = null
};
#region Check input
if (ratingInsertModel == null)
{
responseDto.Status = 400;
responseDto.Message = "Faulthy input";
return(responseDto);
}
if (ratingInsertModel.RatingScore < 0 || ratingInsertModel.RatingScore > 5)
{
responseDto.Status = 400;
responseDto.Message = "Rating is Base 5. Your input is not in Base 5";
return(responseDto);
}
Mentor existingMentor = _uow
.GetRepository <Mentor>()
.GetAll()
.Include(m => m.Rating)
.FirstOrDefault(m => m.MentorId == ratingInsertModel.MentorId);
if (existingMentor == null)
{
responseDto.Status = 404;
responseDto.Message = "Mentor Profile not found";
return(responseDto);
}
#endregion
Rating mentorRating = existingMentor.Rating;
double currentScore = mentorRating.RatingScore.Value;
int currentCount = mentorRating.RatingCount.Value;
int newCount = currentCount + 1;
double calCurrentCount = (double)currentCount;
double calNewCount = (double)newCount;
try
{
mentorRating.RatingScore =
((currentScore * calCurrentCount) + ratingInsertModel.RatingScore) / calNewCount;
mentorRating.RatingCount = newCount;
_uow.GetRepository <Rating>().Update(mentorRating);
_uow.Commit();
}
catch (Exception e)
{
throw e;
}
responseDto.Status = 200;
responseDto.Message = "Success";
return(responseDto);
}
public BaseResponseDto Update(MentorUpdateModel mentorUpdateModel)
{
BaseResponseDto responseDto = null;
if (mentorUpdateModel == null)
{
responseDto = new BaseResponseDto
{
Status = 1,
Message = "Faulthy mentor info"
};
return(responseDto);
}
Mentor existingMentor = null;
try
{
existingMentor = _uow.GetRepository <Mentor>()
.GetAll()
.Include(m => m.User)
.FirstOrDefault(m => m.MentorId == mentorUpdateModel.MentorId);
}
catch (Exception e)
{
throw e;
}
if (existingMentor == null)
{
responseDto = new BaseResponseDto
{
Status = 2,
Message = "No existing mentor with specified id found"
};
return(responseDto);
}
existingMentor.User.Email = mentorUpdateModel.User.Email;
existingMentor.User.Phone = mentorUpdateModel.User.Phone;
existingMentor.User.Fullname = mentorUpdateModel.User.Fullname;
existingMentor.User.YearOfBirth = mentorUpdateModel.User.YearOfBirth;
existingMentor.User.AvatarUrl = mentorUpdateModel.User.AvatarUrl;
existingMentor.User.Balance = mentorUpdateModel.User.Balance;
existingMentor.User.Description = mentorUpdateModel.User.Description;
try
{
_uow.GetRepository <Mentor>().Update(existingMentor);
_uow.Commit();
}
catch (Exception e)
{
throw e;
}
responseDto = new BaseResponseDto
{
Status = 0,
Message = "Success"
};
return(responseDto);
}
public BaseResponseDto Insert(MentorInsertModel mentorInsertModel)
{
BaseResponseDto responseDto = null;
#region Check input
if (mentorInsertModel == null)
{
responseDto = new BaseResponseDto
{
Status = 1,
Message = "Faulthy mentor info"
};
return(responseDto);
}
#endregion
#region Insert mentor into database
Guid userId = Guid.NewGuid();
Guid mentorId = Guid.NewGuid();
try
{
Mentor newMentor = new Mentor
{
MentorId = mentorId,
UserId = userId,
User = new User
{
UserId = userId,
Email = mentorInsertModel.User.Email,
Fullname = mentorInsertModel.User.Fullname,
YearOfBirth = mentorInsertModel.User.YearOfBirth,
AvatarUrl = mentorInsertModel.User.AvatarUrl,
Balance = 0,
Phone = mentorInsertModel.User.Phone,
Description = ""
},
Rating = new Rating
{
MentorId = mentorId,
RatingCount = 0,
RatingScore = 0
},
IsDisable = false
};
_uow.GetRepository <Mentor>().Insert(newMentor);
_uow.Commit();
}
catch (Exception e)
{
throw e;
}
#endregion
string jwtToken = tokenManager.CreateUserAccessToken(new UserAuthModel
{
Id = mentorId,
Email = mentorInsertModel.User.Email,
RoleName = "mentor"
});
responseDto = new BaseResponseDto
{
Status = 0,
Message = jwtToken
};
return(responseDto);
}
public BaseResponseDto GoogleLogin(string mentorEmail)
{
UserAuthModel result = null;
BaseResponseDto responseDto = null;
#region Check input
if (mentorEmail == null)
{
responseDto = new BaseResponseDto
{
Status = 1,
Message = "Email must be specified"
};
return(responseDto);
}
;
try
{
result = _uow
.GetRepository <Mentor>()
.GetAll()
.Include(m => m.User)
.Where(m => m.User.Email == mentorEmail)
.Select(m => new UserAuthModel
{
Id = m.MentorId,
Email = mentorEmail,
RoleName = "mentor"
})
.FirstOrDefault();
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto = new BaseResponseDto
{
Status = 2,
Message = "Mentor " + mentorEmail + " does not exist",
};
return(responseDto);
}
#endregion
#region Generate JWT
// not in used - yet
// string jwtToken = tokenManager.CreateUserAccessToken(result);
#endregion
// finalize
responseDto = new BaseResponseDto
{
Status = 0,
// Message = jwtToken
Message = result.Id.ToString()
};
return(responseDto);
}
public BaseResponseDto <MenteeModel> GetById(string menteeId)
{
IEnumerable <MenteeModel> result = null;
BaseResponseDto <MenteeModel> responseDto = new BaseResponseDto <MenteeModel>
{
Status = 0,
Message = "Success",
Content = null
};
if (menteeId == null)
{
responseDto = new BaseResponseDto <MenteeModel>
{
Status = 1,
Message = "MentorId must be specified",
Content = null
};
return(responseDto);
}
;
try
{
result = _uow
.GetRepository <Mentee>()
.GetAll()
.Include(m => m.User)
.Include(m => m.Subscription)
.ThenInclude(s => s.Channel)
.ThenInclude(c => c.Mentor)
.ThenInclude(m => m.User)
.Include(m => m.Subscription)
.ThenInclude(s => s.Channel)
.ThenInclude(c => c.Topic)
.Where(m => m.MenteeId == new Guid(menteeId))
.Select(m => new MenteeModel
{
MenteeId = m.MenteeId,
User = new UserViewModel
{
UserId = m.User.UserId,
Email = m.User.Email,
Fullname = m.User.Fullname,
Description = m.User.Description,
Phone = m.User.Phone,
AvatarUrl = m.User.AvatarUrl,
Balance = m.User.Balance,
YearOfBirth = m.User.YearOfBirth
},
Subscription = m.Subscription.Select(s => new SubscriptionViewModel
{
SubscriptionId = s.SubscriptionId,
MenteeName = m.User.Email,
ChannelMentorId = s.Channel.Mentor.MentorId,
ChannelMentor = s.Channel.Mentor.User.Email,
ChannelTopicId = s.Channel.Topic.TopicId,
ChannelTopic = s.Channel.Topic.TopicName,
TimeSubscripted = s.TimeSubscripted,
IsDisable = s.IsDisable
}).ToList(),
IsDisable = m.IsDisable
});
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto = new BaseResponseDto <MenteeModel>
{
Status = 2,
Message = "Mentor with id " + menteeId + " does not exist",
Content = null
};
return(responseDto);
}
responseDto.Content = result;
return(responseDto);
}
public BaseResponseDto <MenteeEnrollCountModel> CountEnroll()
{
BaseResponseDto <MenteeEnrollCountModel> responseDto = new BaseResponseDto <MenteeEnrollCountModel>
{
Status = 0,
Message = "Success",
Content = null
};
List <MenteeEnrollCountModel> result = new List <MenteeEnrollCountModel>();
List <Mentee> menteeList = new List <Mentee>();
try
{
menteeList = _uow
.GetRepository <Mentee>()
.GetAll()
.Include(m => m.User)
.Include(m => m.Subscription)
.ThenInclude(m => m.Enroll)
.ToList();
foreach (Mentee mentee in menteeList)
{
int count = 0;
foreach (Subscription subscription in mentee.Subscription)
{
foreach (Enroll enroll in subscription.Enroll)
{
count++;
}
}
MenteeEnrollCountModel model = new MenteeEnrollCountModel
{
MenteeId = mentee.MenteeId,
MenteeEmail = mentee.User.Email,
EnrollCount = count
};
result.Add(model);
}
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto.Status = 1;
responseDto.Message = "There are no topic in the system";
}
;
//finalize
responseDto.Content = result;
return(responseDto);
}
public BaseResponseDto <MenteeEnrolledSharingModel> GetEnrolledSharings(string menteeId)
{
IEnumerable <MenteeEnrolledSharingModel> result = null;
BaseResponseDto <MenteeEnrolledSharingModel> responseDto = new BaseResponseDto <MenteeEnrolledSharingModel>
{
Status = 0,
Message = "Success",
Content = null
};
if (menteeId == null)
{
responseDto = new BaseResponseDto <MenteeEnrolledSharingModel>
{
Status = 1,
Message = "MentorId must be specified",
Content = null
};
return(responseDto);
}
;
try
{
result = _uow
.GetRepository <Mentee>()
.GetAll()
.Include(m => m.Subscription)
.ThenInclude(m => m.Enroll)
.ThenInclude(m => m.Sharing)
.Where(m => m.MenteeId == new Guid(menteeId))
.Select(m => new MenteeEnrolledSharingModel
{
MenteeId = m.MenteeId,
User = new UserViewModel
{
UserId = m.User.UserId,
Email = m.User.Email,
Fullname = m.User.Fullname,
Description = m.User.Description,
Phone = m.User.Phone,
AvatarUrl = m.User.AvatarUrl,
Balance = m.User.Balance,
YearOfBirth = m.User.YearOfBirth
},
Subscriptions = m.Subscription.Select(m => new SubscriptionSharingListModel
{
SubscriptionId = m.SubscriptionId,
Sharings = m.Enroll.Select(m => new SharingViewModel
{
SharingId = m.Sharing.SharingId,
SharingName = m.Sharing.SharingName,
Price = m.Sharing.Price,
MentorName = m.Sharing.Channel.Mentor.User.Fullname,
Description = m.Sharing.Description,
Maximum = m.Sharing.Maximum,
Location = m.Sharing.Location,
StartTime = m.Sharing.StartTime,
EndTime = m.Sharing.EndTime,
ImageUrl = m.Sharing.ImageUrl,
IsApproved = m.Sharing.IsApproved,
IsDisable = m.Sharing.IsDisable
}).ToList()
}).ToList()
});
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto = new BaseResponseDto <MenteeEnrolledSharingModel>
{
Status = 2,
Message = "Mentor with id " + menteeId + " does not exist",
Content = null
};
return(responseDto);
}
responseDto.Content = result;
return(responseDto);
}
public BaseResponseDto <TopicEnrollCountModel> CountEnroll()
{
BaseResponseDto <TopicEnrollCountModel> responseDto = new BaseResponseDto <TopicEnrollCountModel>
{
Status = 200,
Message = "Success",
Content = null
};
List <TopicEnrollCountModel> result = new List <TopicEnrollCountModel>();
List <Topic> topicList = null;
try
{
topicList = _uow
.GetRepository <Topic>()
.GetAll()
.Include(t => t.Channel)
.ThenInclude(t => t.Sharing)
.ThenInclude(t => t.Enroll)
.ToList();
foreach (Topic topic in topicList)
{
int count = 0;
foreach (Channel channel in topic.Channel)
{
foreach (Sharing sharing in channel.Sharing)
{
foreach (Enroll enroll in sharing.Enroll)
{
count++;
}
}
}
TopicEnrollCountModel model = new TopicEnrollCountModel
{
TopicId = topic.TopicId,
TopicName = topic.TopicName,
EnrollCount = count
};
result.Add(model);
}
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto.Status = 404;
responseDto.Message = "There are no topic in the system";
}
;
//finalize
responseDto.Content = result;
return(responseDto);
}
public async Task <BaseResponseDto <UpdateOrderResponseDto> > UpdateOrder(
UpdateOrderRequestDto request,
CancellationToken cancellationToken
)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var payload = new UpdateOrderRequestRemoteDto
{
transport_type = TransportTypeToString(request.TransportType),
cashed = request.Cashed,
credit = request.Credit,
delay = request.Delay,
has_return = request.HasReturn,
pay_at_dest = request.PayAtDest
};
var payloadJson = JsonSerializer.Serialize(payload);
var path = UpdateOrderV2EndpointPath.Replace(OrderIdPlaceholder, request.OrderId);
var retryContext = await RetryHandler.BeginTry(cancellationToken);
HttpResponseMessage response = null;
bool retry = false;
var content = new StringContent(payloadJson, Encoding.UTF8, ApplicationJsonMime);
path = CreatePath(path);
do
{
try
{
response = await Send(
new HttpRequestMessage(HttpMethod.Put, path)
{
Content = content
},
cancellationToken
);
if (!response.IsSuccessStatusCode)
{
return(await ThrowOnInvalidStatusCode <UpdateOrderResponseDto>(response));
}
await RetryHandler.EndTry(retryContext, cancellationToken);
}
catch (Exception ex)
{
retry = await RetryHandler.CatchException(retryContext, ex, cancellationToken);
}
} while (retry);
if (response is null)
{
throw new InvalidOperationException();
}
var responseStream = await response.Content.ReadAsStreamAsync();
var result =
JsonSerializer.Deserialize <RemoteBaseResponseDto <UpdateOrderResponseRemoteDto> >(responseStream);
if (result is null)
{
throw new AlopeykException("Object was empty in alopeyk's response.");
}
var obj = result.@object;
UpdateOrderResponseDto resultObject = null;
if (!(obj is null))
{
resultObject = new UpdateOrderResponseDto();
MapGetOrderDetailsResponseRDtoToResponseDto(resultObject, obj);
}
var output = new BaseResponseDto <UpdateOrderResponseDto>
{
Status = FormatStatusCode(result.status),
Message = result.message,
Object = resultObject
};
BindBaseResponse(output, response);
return(output);
}
public async Task <BaseResponseDto <ResponseLoginDto> > Login([FromBody] LoginUserRequest loginUserRequest)
{
BaseResponseDto <ResponseLoginDto> response = await _mediator.Send(loginUserRequest);
return(response);
}
public BaseResponseDto <ChannelModel> GetById(string channelId)
{
IEnumerable <ChannelModel> result = null;
BaseResponseDto <ChannelModel> responseDto = new BaseResponseDto <ChannelModel>
{
Status = 0,
Message = "Success",
Content = null
};
if (channelId == null)
{
responseDto = new BaseResponseDto <ChannelModel>
{
Status = 1,
Message = "ChannelId must be specified",
Content = null
};
return(responseDto);
}
;
try
{
result = _uow
.GetRepository <Channel>()
.GetAll()
.Include(c => c.Topic)
.Include(c => c.Mentor)
.ThenInclude(c => c.User)
.Include(c => c.Mentor)
.ThenInclude(c => c.Rating)
.Include(c => c.Subscription)
.ThenInclude(c => c.Mentee)
.ThenInclude(c => c.User)
.Include(c => c.Sharing)
.Include(c => c.Subscription)
.Where(c => c.ChannelId.Equals(new Guid(channelId)))
.Select(c => new ChannelModel
{
ChannelId = c.ChannelId,
IsDisable = c.IsDisable,
Mentor = new MentorViewModel
{
MentorId = c.Mentor.MentorId,
Email = c.Mentor.User.Email,
Fullname = c.Mentor.User.Fullname,
AvatarUrl = c.Mentor.User.AvatarUrl,
Description = c.Mentor.User.Description,
Rating = new RatingViewModel
{
RatingScore = c.Mentor.Rating.RatingScore
},
Channels = new List <ChannelViewModel>() // its supposed to be empty
},
Topic = new TopicViewModel
{
TopicId = c.Topic.TopicId,
TopicName = c.Topic.TopicName,
MajorId = c.Topic.MajorId,
CreatedBy = c.Topic.CreatedBy
},
Sharing = c.Sharing.Select(s => new SharingViewModel
{
SharingId = s.SharingId,
SharingName = s.SharingName,
MentorName = s.Channel.Mentor.User.Email,
Description = s.Description,
Maximum = s.Maximum,
Location = s.Location,
StartTime = s.StartTime,
EndTime = s.EndTime,
ImageUrl = s.ImageUrl,
Price = s.Price,
IsApproved = s.IsApproved,
IsDisable = s.IsDisable
}).ToList(),
Subscription = c.Subscription.Select(s => new SubscriptionViewModel
{
SubscriptionId = s.SubscriptionId,
MenteeName = s.Mentee.User.Email,
ChannelMentor = s.Channel.Mentor.User.Email,
ChannelTopic = s.Channel.Topic.TopicName,
TimeSubscripted = s.TimeSubscripted,
IsDisable = s.IsDisable
}).ToList()
});
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto = new BaseResponseDto <ChannelModel>
{
Status = 2,
Message = "Channel with id " + channelId + " does not exist",
Content = null
};
return(responseDto);
}
responseDto.Content = result;
return(responseDto);
}
public async Task <BaseResponseDto <IEnumerable <GetPriceResponseDto> > > GetPrices(
IEnumerable <GetPriceRequestDto> requests,
CancellationToken cancellationToken
)
{
if (requests is null)
{
throw new ArgumentNullException(nameof(requests));
}
var payload = requests.Select(GetPriceLocalRequestToRemoteRequest);
var payloadJson = JsonSerializer.Serialize(payload);
var path = GetPricesV2EndpointPath;
var retryContext = await RetryHandler.BeginTry(cancellationToken);
HttpResponseMessage response = null;
bool retry = false;
var content = new StringContent(payloadJson, Encoding.UTF8, ApplicationJsonMime);
path = CreatePath(path);
do
{
try
{
response = await Send(
new HttpRequestMessage(HttpMethod.Post, path)
{
Content = content
},
cancellationToken
);
if (!response.IsSuccessStatusCode)
{
return(await ThrowOnInvalidStatusCode <IEnumerable <GetPriceResponseDto> >(response));
}
await RetryHandler.EndTry(retryContext, cancellationToken);
}
catch (Exception ex)
{
retry = await RetryHandler.CatchException(retryContext, ex, cancellationToken);
}
} while (retry);
if (response is null)
{
throw new InvalidOperationException();
}
var responseStream = await response.Content.ReadAsStreamAsync();
var result = JsonSerializer.Deserialize <RemoteBaseResponseDto <GetPriceResponseRemoteDto[]> >(responseStream);
if (result is null)
{
throw new AlopeykException("Object was empty in alopeyk's response.");
}
var output = new BaseResponseDto <IEnumerable <GetPriceResponseDto> >
{
Status = FormatStatusCode(result.status),
Message = result.message,
Object = result.@object?
.Select(GetPriceRemoteResponseToLocalResponse)
.ToArray()
};
BindBaseResponse(output, response);
return(output);
}
public async Task <BaseResponseDto <DeleteHiddenDescriptionResponseDto> > DeleteHiddenDescription(
DeleteHiddenDescriptionRequestDto request,
CancellationToken cancellationToken
)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var path = DeleteHiddenDescriptionV2EndpointPath.Replace(OrderIdPlaceholder, request.OrderId);
path = path.Replace(AddressIdPlaceholder, request.AddressId);
path = path.Replace(HiddenDescriptionIdPlaceholder, request.HiddenDescriptionId);
var retryContext = await RetryHandler.BeginTry(cancellationToken);
HttpResponseMessage response = null;
bool retry = false;
path = CreatePath(path);
do
{
try
{
response = await Send(
new HttpRequestMessage(HttpMethod.Delete, path),
cancellationToken
);
if (!response.IsSuccessStatusCode)
{
return(await ThrowOnInvalidStatusCode <DeleteHiddenDescriptionResponseDto>(response));
}
await RetryHandler.EndTry(retryContext, cancellationToken);
}
catch (Exception ex)
{
retry = await RetryHandler.CatchException(retryContext, ex, cancellationToken);
}
} while (retry);
if (response is null)
{
throw new InvalidOperationException();
}
var responseStream = await response.Content.ReadAsStreamAsync();
var result =
JsonSerializer.Deserialize <RemoteBaseResponseDto <DeleteHiddenDescriptionResponseRemoteDto> >(
responseStream);
if (result is null)
{
throw new AlopeykException("Object was empty in alopeyk's response.");
}
var obj = result.@object;
var output = new BaseResponseDto <DeleteHiddenDescriptionResponseDto>
{
Status = FormatStatusCode(result.status),
Message = result.message,
Object = new DeleteHiddenDescriptionResponseDto
{
Id = obj.id,
Description = obj.description,
AddressId = obj.address_id,
CreatedAt = obj.created_at,
OrderId = obj.order_id,
UpdatedAt = obj.updated_at,
UserId = obj.user_id
}
};
BindBaseResponse(output, response);
return(output);
}
public async Task <BaseResponseDto <PostDto> > Post([FromBody] CreatePostRequest createPostRequest)
{
BaseResponseDto <PostDto> response = await _mediator.Send(createPostRequest);
return(response);
}
public BaseResponseDto <MentorModel> GetById(string mentorId)
{
IEnumerable <MentorModel> result = null;
BaseResponseDto <MentorModel> responseDto = new BaseResponseDto <MentorModel>
{
Status = 0,
Message = "Success",
Content = null
};
if (mentorId == null)
{
responseDto = new BaseResponseDto <MentorModel>
{
Status = 1,
Message = "MentorId must be specified",
Content = null
};
return(responseDto);
}
;
try
{
result = _uow
.GetRepository <Mentor>()
.GetAll()
.Include(m => m.User)
.Include(m => m.Channel)
.Where(m => m.MentorId == new Guid(mentorId))
.Select(m => new MentorModel
{
MentorId = m.MentorId,
User = new UserViewModel
{
UserId = m.User.UserId,
Email = m.User.Email,
Fullname = m.User.Fullname,
Description = m.User.Description,
Phone = m.User.Phone,
AvatarUrl = m.User.AvatarUrl,
Balance = m.User.Balance,
YearOfBirth = m.User.YearOfBirth
},
Rating = new RatingViewModel
{
RatingScore = m.Rating.RatingScore
},
Channels = m.Channel.Select(c => new ChannelViewModel
{
ChannelId = c.ChannelId,
MentorName = m.User.Email,
TopicName = c.Topic.TopicName,
IsDisable = c.IsDisable
}).ToList(),
IsDisable = m.IsDisable
});
}
catch (Exception e)
{
throw e;
}
if (result == null)
{
responseDto = new BaseResponseDto <MentorModel>
{
Status = 2,
Message = "Mentor with id " + mentorId + " does not exist",
Content = null
};
return(responseDto);
}
responseDto.Content = result;
return(responseDto);
}
protected virtual void BindBaseResponse <T>(
BaseResponseDto <T> result,
HttpResponseMessage response
)
{
if (response.Headers.TryGetValues("X-MinuteRateLimit-Identifier",
out var valuesMinuteRateLimitIdentifierStr))
{
result.MinuteRateLimitIdentifier = valuesMinuteRateLimitIdentifierStr.FirstOrDefault();
}
if (response.Headers.TryGetValues("X-MinuteRateLimit-Limit", out var valuesMinuteRateLimitLimitStr))
{
if (int.TryParse(valuesMinuteRateLimitLimitStr.FirstOrDefault(), out var valuesMinuteRateLimitLimit))
{
result.MinuteRateLimitLimit = valuesMinuteRateLimitLimit;
}
}
if (response.Headers.TryGetValues("X-MinuteRateLimit-Remaining", out var valuesMinuteRateLimitRemainingStr))
{
if (int.TryParse(valuesMinuteRateLimitRemainingStr.FirstOrDefault(),
out var valuesMinuteRateLimitRemaining))
{
result.MinuteRateLimitRemaining = valuesMinuteRateLimitRemaining;
}
}
if (response.Headers.TryGetValues("X-DailyRateLimit-Identifier", out var valuesDailyRateLimitIdentifierStr))
{
result.DailyRateLimitIdentifier = valuesDailyRateLimitIdentifierStr.FirstOrDefault();
}
if (response.Headers.TryGetValues("X-DailyRateLimit-Limit", out var valuesDailyRateLimitLimitStr))
{
if (int.TryParse(valuesDailyRateLimitLimitStr.FirstOrDefault(), out var valuesDailyRateLimitLimit))
{
result.DailyRateLimitLimit = valuesDailyRateLimitLimit;
}
}
if (response.Headers.TryGetValues("X-DailyRateLimit-Remaining", out var valuesDailyRateLimitRemainingStr))
{
if (int.TryParse(valuesDailyRateLimitRemainingStr.FirstOrDefault(),
out var valuesDailyRateLimitRemaining))
{
result.DailyRateLimitRemaining = valuesDailyRateLimitRemaining;
}
}
if (response.Headers.TryGetValues("X-RateLimit-Identifier", out var valuesRateLimitIdentifierStr))
{
result.RateLimitIdentifier = valuesRateLimitIdentifierStr.FirstOrDefault();
}
if (response.Headers.TryGetValues("X-RateLimit-Limit", out var valuesRateLimitLimitStr))
{
if (int.TryParse(valuesRateLimitLimitStr.FirstOrDefault(), out var valuesRateLimitLimit))
{
result.RateLimitLimit = valuesRateLimitLimit;
}
}
if (response.Headers.TryGetValues("X-RateLimit-Remaining", out var valuesRateLimitRemainingStr))
{
if (int.TryParse(valuesRateLimitRemainingStr.FirstOrDefault(),
out var valuesRateLimitRemaining))
{
result.RateLimitRemaining = valuesRateLimitRemaining;
}
}
}
