/// <summary>
/// Fixed:
/// </summary>
public static System.Web.Mvc.ContentResult DeleteByApi(Context context)
{
var api = context.RequestDataString.Deserialize <SessionApi>();
if (api == null || api.SessionKey.IsNullOrEmpty())
{
return(ApiResults.Get(ApiResponses.BadRequest(context: context)));
}
if (GetUserArea(context, api.SessionKey, api.SavePerUser) == null)
{
return(ApiResults.Get(ApiResponses.NotFound(context)));
}
try
{
DeleteUserArea(
context: context,
key: api.SessionKey,
page: false,
sessionGuid: api.SavePerUser ? "@" + context.UserId : context.SessionGuid);
}
catch
{
return(ApiResults.Get(ApiResponses.Error(context, new ErrorData(Error.Types.InternalServerError))));
}
return(ApiResults.Get(new
{
StatusCode = 200,
Response = new
{
context.UserId,
Key = api.SessionKey
}
}.ToJson()));
}
/// <summary>
/// Fixed:
/// </summary>
public static System.Web.Mvc.ContentResult GetByApi(Context context)
{
var api = context.RequestDataString.Deserialize <SessionApi>();
if (api == null || api.SessionKey.IsNullOrEmpty())
{
return(ApiResults.Get(ApiResponses.BadRequest(context: context)));
}
var value = GetUserArea(
context: context,
key: api.SessionKey,
useUserSessionData: api.SavePerUser);
if (value == null)
{
return(ApiResults.Get(ApiResponses.NotFound(context)));
}
return(ApiResults.Get(new
{
StatusCode = 200,
Response = new
{
context.UserId,
Key = api.SessionKey,
Value = value
}
}.ToJson()));
}
protected async Task <ApiResponse <GetAllResponse <TEntityOutput> > > GetAll(Func <TEntity, bool> whereExpression = null)
{
var useCaseResult = await UseCaseReadOnlyInteractor.GetAll(whereExpression);
var wasSuccessfullyExecuted = useCaseResult.Success;
if (!wasSuccessfullyExecuted)
{
var failureResult = new GetAllResponse <TEntityOutput>
{
Items = new List <TEntityOutput>(),
TotalCount = 0
};
return(ApiResponses.Failure(failureResult, useCaseResult.Message));
}
var entityOutputs = useCaseResult.Result.Items.Select(result => Activator.CreateInstance(typeof(TEntityOutput), result) as TEntityOutput).ToList();
var getAllOutput = new GetAllResponse <TEntityOutput>
{
Items = entityOutputs,
TotalCount = useCaseResult.Result.TotalCount
};
return(ApiResponses.Success(getAllOutput));
}
public async Task <ApiResponse <UserOutput> > Update([FromBody] UserInput userToUpdate)
{
var user = await _users.GetById(userToUpdate.Id);
if (!user.Success)
{
return(ApiResponses.Failure <UserOutput>("User doesnt exists"));
}
var isUpdatingPassword = userToUpdate.Password != user.Response.Password;
if (isUpdatingPassword)
{
var isPasswordConfirmed = userToUpdate.Password == userToUpdate.PasswordConfirmation;
if (!isPasswordConfirmed)
{
return(ApiResponses.Failure <UserOutput>("Passwords doesnt matches"));
}
}
var userId = User.Claims.ToList()[2];
var modifierId = Guid.Parse(userId.Value);
userToUpdate.Role = UserRoles.NonAdmin;
return(await base.Update(userToUpdate, modifierId));
}
/// <summary>
/// Fixed:
/// </summary>
public static System.Web.Mvc.ContentResult SetByApi(Context context)
{
var api = context.RequestDataString.Deserialize <SessionApi>();
if (api == null || api.SessionKey.IsNullOrEmpty() || api.SessionValue.IsNullOrEmpty())
{
return(ApiResults.Get(ApiResponses.BadRequest(context: context)));
}
try
{
SetUserArea(
context: context,
key: api.SessionKey,
value: api.SessionValue,
page: false);
}
catch
{
return(ApiResults.Get(ApiResponses.Error(context, new ErrorData(Error.Types.InternalServerError))));
}
return(ApiResults.Get(new
{
StatusCode = 200,
Response = new
{
context.UserId,
Key = api.SessionKey
}
}.ToJson()));
}
public System.Web.Mvc.ContentResult GetByApi()
{
SetSite();
switch (Site.ReferenceType)
{
case "Issues":
if (SiteId == ReferenceId)
{
return(IssueUtilities.GetByApi(
ss: Site.IssuesSiteSettings(ReferenceId)));
}
else
{
return(IssueUtilities.GetByApi(
ss: Site.IssuesSiteSettings(ReferenceId),
issueId: ReferenceId));
}
case "Results":
if (SiteId == ReferenceId)
{
return(ResultUtilities.GetByApi(
ss: Site.ResultsSiteSettings(ReferenceId)));
}
else
{
return(ResultUtilities.GetByApi(
ss: Site.ResultsSiteSettings(ReferenceId),
resultId: ReferenceId));
}
default: return(ApiResults.Get(ApiResponses.BadRequest()));
}
}
// TODO Migrate to UseCases
public async Task <ApiResponse <decimal> > GetRentAverageTicketWithDiscount(Guid rentId)
{
var rent = await GetById(rentId);
return(!rent.Success
? ApiResponses.Failure(0M, rent.Message)
: ApiResponses.Success(rent.Response.AverageTicketWithDiscount));
}
// TODO Migrate to UseCases
public async Task <ApiResponse <DateRange> > GetRentPeriod(Guid rentId)
{
var rent = await GetById(rentId);
return(!rent.Success
? ApiResponses.Failure(DateRangeProvider.GetDateRange(DateTime.MinValue, DateTime.MinValue.AddTicks(1)).Result, rent.Message)
: ApiResponses.Success(rent.Response.RentPeriod));
}
// TODO Migrate to UseCases
public async Task <ApiResponse <int> > GetLateDays(Guid rentId)
{
var rent = await GetById(rentId);
return(!rent.Success
? ApiResponses.Failure(0, rent.Message)
: ApiResponses.Success(rent.Response.LateDays));
}
public async Task <IActionResult> OpenRoulette(int id)
{
var roulette = await _rouletteService.OpenRoulette(id);
var response = new ApiResponses <bool>(roulette);
return(Ok(response));
}
public async Task <IActionResult> CloseBetById(int id)
{
var bet = await _betService.SelectBetByRoulette(id);
var betDto = _mapper.Map <IEnumerable <BetDto> >(bet);
var response = new ApiResponses <IEnumerable <BetDto> >(betDto);
return(Ok(response));
}
public async Task <IActionResult> GetRoulettes()
{
var roulettes = await _rouletteService.GetRoulettes();
var rouletteDto = _mapper.Map <IEnumerable <RouletteDto> >(roulettes);
var response = new ApiResponses <IEnumerable <RouletteDto> >(rouletteDto);
return(Ok(response));
}
public async Task <IActionResult> InsertRoulette(RouletteDto rouletteDto)
{
var roulette = _mapper.Map <Roulette>(rouletteDto);
await _rouletteService.InsertRoulette(roulette);
rouletteDto = _mapper.Map <RouletteDto>(roulette);
var response = new ApiResponses <int>(rouletteDto.id_roulette);
return(Ok(response));
}
public IActionResult Abonent(int id)
{
Console.WriteLine($"Мы получаем id = {id}");
byte[] hash = Encoding.ASCII.GetBytes($"service_ext,{id},brtS9$P9_W");
MD5 md5 = new MD5CryptoServiceProvider();
byte[] hashenc = md5.ComputeHash(hash);
string sign = "";
foreach (var b in hashenc)
{
sign += b.ToString("x2");
}
Console.WriteLine(sign);
// Create a request using a URL that can receive a post.
WebRequest request = WebRequest.Create($"http://test-partner.demo.platform-api.dev.enaza.ru/api/subscription/getShippingData?userId={id}&productCode=service_ext&sign={sign}");
//sign=eb96e3e791b7d9f2104a6ca7bdca0a10
// Get the response.
WebResponse response = request.GetResponse();
// Display the status.
Console.WriteLine(((HttpWebResponse)response).StatusDescription);
// Get the stream containing content returned by the server.
// The using block ensures the stream is automatically closed.
using (Stream dataStream = response.GetResponseStream())
{
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
string responseFromServer = reader.ReadToEnd();
// Display the content.
Console.WriteLine(responseFromServer);
ApiResponses responses = new ApiResponses();
responses.getShippingData = JsonConvert.DeserializeObject <getShippingData>(responseFromServer);
//Console.WriteLine(responses.getShippingData.distrList[0].key);
// Console.WriteLine(responses.getShippingData.keyList[0].name);
// Console.WriteLine(responses.getShippingData.distrList[1]);
return(View(responses));
}
//return "Thanks " + customer.Name;
}
public async Task <ApiResponse <GetAllResponse <RenterOutput> > > GetBirthDaysOnPeriod(GetBirthDaysOnPeriodInput input)
{
var period = DateRangeProvider.GetDateRange(input.StartDate, input.EndDate);
if (!period.Success)
{
return(ApiResponses.Failure <GetAllResponse <RenterOutput> >(period.Message));
}
return(await GetAll(r => period.Result.IsMonthOnRange(r.BirthDate.Date.Month)));
}
// TODO Migrate to UseCases
public async Task <ApiResponse <GetAllResponse <RentOutput> > > GetOpenRentsFromPeriod(PeriodInput input)
{
var period = DateRangeProvider.GetDateRange(input.StartDate, input.EndDate);
if (!period.Success)
{
return(ApiResponses.Failure <GetAllResponse <RentOutput> >(period.Message));
}
return(await GetAll(r => r.IsOpen && period.Result.IsOnRange(r.RentPeriod)));
}
public ApiResponse WakeUp()
{
try
{
return(ApiResponses.Success(null));
}
catch (Exception ex)
{
return(ApiResponses.InternalError(null, ex.Message));
}
}
public virtual async Task <ApiResponse <List <TEntityOutput> > > GetByIds(List <Guid> ids)
{
var useCaseResult = await UseCaseReadOnlyInteractor.GetByIds(ids);
var wasSuccessfullyExecuted = useCaseResult.Success;
var entityOutputs = useCaseResult.Result.Select(result => Activator.CreateInstance(typeof(TEntityOutput), result) as TEntityOutput).ToList();
return(wasSuccessfullyExecuted
? ApiResponses.Success(entityOutputs)
: ApiResponses.Failure(entityOutputs, useCaseResult.Message));
}
public System.Web.Mvc.ContentResult CreateByApi()
{
SetSite();
switch (Site.ReferenceType)
{
case "Issues": return(IssueUtilities.CreateByApi(
ss: Site.IssuesSiteSettings(ReferenceId)));
case "Results": return(ResultUtilities.CreateByApi(
ss: Site.ResultsSiteSettings(ReferenceId)));
default: return(ApiResults.Get(ApiResponses.BadRequest()));
}
}
public virtual async Task <ApiResponse <TEntityOutput> > GetById(Guid id)
{
var useCaseResult = await UseCaseReadOnlyInteractor.GetById(id);
var wasSuccessfullyExecuted = useCaseResult.Success;
if (!wasSuccessfullyExecuted)
{
return(ApiResponses.Failure(Activator.CreateInstance <TEntityOutput>(), useCaseResult.Message));
}
var entityOutput = Activator.CreateInstance(typeof(TEntityOutput), useCaseResult.Result) as TEntityOutput;
return(ApiResponses.Success(entityOutput));
}
protected ActionResult <ApiResponses <ResponseDto> > GetAll(
IReaderGetAll <DataModel> readerGetAll,
IMapper mapper)
{
var responseDtos = readerGetAll
.GetAll()
.Select(mapper.Map <ResponseDto>)
.ToList();
var responseDto = new ApiResponses <ResponseDto>
{
Elements = responseDtos
};
return(Ok(responseDto));
}
protected ActionResult <ApiResponses <ResponseDto> > Search <RequestDto, Query>(
RequestDto searchDto,
IReaderSearch <Query, DataModel> readerSearch,
IMapper mapper)
{
var responseDtos = readerSearch
.Search(mapper.Map <Query>(searchDto))
.Select(mapper.Map <ResponseDto>)
.ToList();
var responseDto = new ApiResponses <ResponseDto>
{
Elements = responseDtos
};
return(Ok(responseDto));
}
public async Task <ApiResponse <UserOutput> > Create([FromBody] UserInput userToCreate)
{
var isPasswordConfirmed = userToCreate.Password == userToCreate.PasswordConfirmation;
if (!isPasswordConfirmed)
{
return(ApiResponses.Failure <UserOutput>("Passwords doesnt matches"));
}
userToCreate.Id = Guid.NewGuid();
var userId = User.Claims.ToList()[2];
var creatorId = Guid.Parse(userId.Value);
userToCreate.Role = UserRoles.NonAdmin;
return(await base.Create(userToCreate, creatorId));
}
public ApiResponse Create(string channelName)
{
try
{
var response = _channelService.GetChannel(channelName);
if (response != null)
{
return(ApiResponses.Success(response));
}
return(ApiResponses.NotFound(channelName));
}
catch (Exception ex)
{
return(ApiResponses.InternalError(null, ex.Message));
}
}
public ApiResponse SendMessageChannel([FromBody] MessageRequest request)
{
try
{
var response = _notifierService.SendMessageToChannel(request.ChannelName, request.Message).GetAwaiter().GetResult();
if (response)
{
return(ApiResponses.Success(null));
}
return(null);
}
catch (Exception ex)
{
return(ApiResponses.InternalError(null, ex.Message));
}
}
public ApiResponse Create(Channel input)
{
try
{
var response = _channelService.Create(input);
if (response != null)
{
return(ApiResponses.Success(response));
}
return(ApiResponses.Conflict(input.ChannelName, "Channel already exists!"));
}
catch (Exception ex)
{
return(ApiResponses.InternalError(null, ex.Message));
}
}
public ApiResponse UpdateUsers(string channelId, List <User> users)
{
try
{
var response = _channelService.UpdateUsers(channelId, users);
if (response != null)
{
return(ApiResponses.Success(response));
}
return(ApiResponses.NotFound(channelId));
}
catch (Exception ex)
{
return(ApiResponses.InternalError(null, ex.Message));
}
}
protected internal async Task <ApiResponse <TEntityOutput> > Update(TEntityInput entityToUpdate, Guid modifierId)
{
var entity = entityToUpdate.MapToEntity();
entity.Id = entityToUpdate.Id;
entity.Code = entityToUpdate.Code;
entity.Name = entityToUpdate.Name;
entity.CreatorId = modifierId;
var useCaseResult = await UseCaseInteractor.Update(entity);
var wasSuccessfullyExecuted = useCaseResult.Success;
if (!wasSuccessfullyExecuted)
{
return(ApiResponses.Failure(Activator.CreateInstance <TEntityOutput>(), useCaseResult.Message));
}
var entityOutput = Activator.CreateInstance(typeof(TEntityOutput), useCaseResult.Result) as TEntityOutput;
return(ApiResponses.Success(entityOutput));
}
public async Task <IActionResult> SelectBets([FromQuery] BetQueryFilter filters)
{
var bets = await _betService.SelectBets(filters);
var betDto = _mapper.Map <IEnumerable <BetDto> >(bets);
var metaData = new MetaData {
TotalCount = bets.TotalCount,
PageSize = bets.PageSize,
CurrentPage = bets.CurrentPage,
TotalPages = bets.TotalPages,
HasNextPage = bets.HasNextPage,
HasPreviousPage = bets.HasPreviousPage,
NextPageUrl = _urlService.getPostPaginationUrl(filters, Url.RouteUrl(nameof(SelectBets))).ToString(),
PreviousPageUrl = _urlService.getPostPaginationUrl(filters, Url.RouteUrl(nameof(SelectBets))).ToString()
};
var response = new ApiResponses <IEnumerable <BetDto> >(betDto)
{
Meta = metaData
};
Response.Headers.Add("x-Pagination", JsonConvert.SerializeObject(metaData));
return(Ok(response));
}
public async Task <ApiResponse <GetAllResponse <ProductRentalHistoryOutput> > > GetRentalHistory(Guid productId)
{
return(await ApiResponses.GetUseCaseInteractorResponse <ProductRentalHistory, ProductRentalHistoryOutput>(_productRentalHistoryUseCasesReadOnlyInteractor.GetRentalHistory, productId));
}
