public HttpResponseMessage GetAllByPlayerId(int playerId)
{
using (ContractDBContext db = new ContractDBContext())
{
List <ResponseContract> returnList = new List <ResponseContract>();
foreach (var item in db.Contracts.Where(x => x.PlayerId == playerId).OrderByDescending(x => x.StartAt).ToList())
{
ResponseContract itemToAdd = new ResponseContract();
var Client = new RestClient(ConfigurationManager.AppSettings["SERVICE_ADDRESS_PLAYER"]);
var uri = string.Format("/players/{0}", item.PlayerId);
var request = new RestRequest(uri, Method.GET);
request.AddParameter("Authorization", string.Format("Bearer " + ConfigurationManager.AppSettings["SERVICE_AUTHKEY"]), ParameterType.HttpHeader);
IRestResponse response = Client.Execute(request);
var responsePlayer = JsonConvert.DeserializeObject <ResponsePlayer>(response.Content);
Client = new RestClient(ConfigurationManager.AppSettings["SERVICE_ADDRESS_TEAM"]);
uri = string.Format("/teams/{0}", item.TeamId);
request = new RestRequest(uri, Method.GET);
request.AddParameter("Authorization", string.Format("Bearer " + ConfigurationManager.AppSettings["SERVICE_AUTHKEY"]), ParameterType.HttpHeader);
response = Client.Execute(request);
var responseTeam = JsonConvert.DeserializeObject <ResponseTeam>(response.Content);
itemToAdd = Mapper.Map <ResponseContract>(item);
itemToAdd.Player = responsePlayer;
itemToAdd.Team = responseTeam;
returnList.Add(itemToAdd);
}
return(Request.CreateResponse(HttpStatusCode.OK, returnList));
}
}
public HttpResponseMessage Get(int id)
{
using (ContractDBContext db = new ContractDBContext())
{
ResponseContract returnItem = new ResponseContract();
Contract item = db.Contracts.Find(id);
if (item == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound, returnItem));
}
else
{
var Client = new RestClient(ConfigurationManager.AppSettings["SERVICE_ADDRESS_PLAYER"]);
var uri = string.Format("/players/{0}", item.PlayerId);
var request = new RestRequest(uri, Method.GET);
request.AddParameter("Authorization", string.Format("Bearer " + ConfigurationManager.AppSettings["SERVICE_AUTHKEY"]), ParameterType.HttpHeader);
IRestResponse response = Client.Execute(request);
var responsePlayer = JsonConvert.DeserializeObject <ResponsePlayer>(response.Content);
Client = new RestClient(ConfigurationManager.AppSettings["SERVICE_ADDRESS_TEAM"]);
uri = string.Format("/teams/{0}", item.TeamId);
request = new RestRequest(uri, Method.GET);
request.AddParameter("Authorization", string.Format("Bearer " + ConfigurationManager.AppSettings["SERVICE_AUTHKEY"]), ParameterType.HttpHeader);
response = Client.Execute(request);
var responseTeam = JsonConvert.DeserializeObject <ResponseTeam>(response.Content);
returnItem = Mapper.Map <ResponseContract>(item);
returnItem.Player = responsePlayer;
returnItem.Team = responseTeam;
return(Request.CreateResponse(HttpStatusCode.OK, returnItem));
}
}
}
public ResponseContract BuildResponse()
{
RepresentationContract[] representations =
{
RepresentationContract.Create("application/json", null, GetSchemaDefinition(), GetResponseSampleCode(), null)
};
return(ResponseContract.Create(GetStatusCode(), _response.Description, representations));
}
public async Task <ResponseContract <CampanhaViewModel> > GetByIdAsync()
{
var response = new ResponseContract <CampanhaViewModel>();
var model = await _campanhaRepository.GetByIdAsync(_user.GetCampaignId());
response.SetContent(_mapper.Map <CampanhaViewModel>(model));
response.SetValid();
return(response);
}
public async Task <ResponseContract <IEnumerable <ProdutoCampanhaViewModel> > > GetAllProductCampaignByCampaignIdAsync()
{
var response = new ResponseContract <IEnumerable <ProdutoCampanhaViewModel> >();
var model = await _produtoCampanhaRepository.GetAllByCampaignIdAsync(_user.GetCampaignId(), _user.GetWallet());
response.SetContent(_mapper.Map <IEnumerable <ProdutoCampanhaViewModel> >(model));
response.SetValid();
return(response);
}
private ResponseContract[] Responses()
{
ResponseContract[] responses =
{
ResponseContract.Create(200, "OK!", new RepresentationContract[] {
RepresentationContract.Create("application/json", null, "typeName", null, null),
RepresentationContract.Create("text/json", null, "typeName", "sample data", Parameters()),
}),
ResponseContract.Create(201, "Created", null),
};
return(responses);
}
public async Task <ResponseContract <ResgateViewModel> > MakeRedemptionAsync(ResgateViewModel request)
{
var response = new ResponseContract <ResgateViewModel>();
response.SetContent(request);
try
{
var product = await _produtoCampanhaRepository.FindByAsync(request.ProdutoCampanhaId, request.CampanhaProdutoId, request.ProdutoId, _user.GetCampaignId(), _user.GetWallet());
if (product == null || product.CampanhaProduto == null)
{
response.AddError(Resources.ProductInvalid);
return(response);
}
if (product.CampanhaProduto.Campanha == null || product.CampanhaProduto.Campanha.DesabilitaResgate.GetValueOrDefault())
{
response.AddError(Resources.CampaignInvalid);
return(response);
}
if (await _usuarioPremioRepository.HasPrizeAsync(_user.GetUserId()))
{
response.AddError(Resources.UserAlreadyRedemption);
return(response);
}
_usuarioPremioRepository.BeginTransaction();
var usuarioPremio = new UsuarioPremio(_user.GetUserId(), request.CampanhaProdutoId,
Enum.UsuarioPremioStatus.AGUARDANDO_PROCESSAMENTO.GetHashCode(), DateTime.Now);
usuarioPremio = await _usuarioPremioRepository.InsertAsync(usuarioPremio);
_usuarioPremioRepository.Commit();
response.SetValid();
_logger.LogWarning($"[UsuarioId: {_user.GetUserId()}] [CPF: {_user.GetUserDocument()}] realizou o resgate - [CampanhaProduto: {request.CampanhaProdutoId}] [Produto: {request.ProdutoId}] .");
await _authService.RefreshClaims();
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
_usuarioPremioRepository.Rollback();
response.AddError(Resources.ErrorOnMakeWish);
}
return(response);
}
public async Task <ResponseContract <UsuarioStatusFaseViewModel> > GetUserStatusFaseAsync()
{
var response = new ResponseContract <UsuarioStatusFaseViewModel>(true, new UsuarioStatusFaseViewModel());
try
{
var vm = new UsuarioStatusFaseViewModel();
var campanhaFase = await _campanhaFaseRepository.GetCurrentAsync(_user.GetCampaignId());
if (campanhaFase == null)
{
campanhaFase = await _campanhaFaseRepository.GetLastFaseAsync(_user.GetCampaignId());
}
//vm.CampanhaFase = _mapper.Map<CampanhaFaseViewModel>(campanhaFase);
var model = await _usuarioStatusFaseRepository.GetByUserIdAndCampaignAndCampaignFaseActiveAsync(_user.GetUserId(), _user.GetCampaignId(), campanhaFase.CampanhaFaseId);
if (model != null)
{
vm = _mapper.Map <UsuarioStatusFaseViewModel>(model);
vm.PossuiFase = true;
}
else
{
var vmComplemento = await _usuarioComplementoRepository.GetByUserIdAndTypeComplementAndNameAsync(_user.GetUserId(), TipoComplemento.Meta, campanhaFase.GetMetaName());
if (vmComplemento != null)
{
var meta = _mapper.Map <UsuarioComplementoViewModel>(vmComplemento);
if (meta != null)
{
vm.Meta = Convert.ToDecimal(meta.Valor);
}
}
}
response.SetContent(vm);
response.SetValid();
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
return(response);
}
public async Task <ResponseContract <ProdutoCampanhaViewModel> > GetProductCampaignByCampaignIdAsync(int id)
{
var response = new ResponseContract <ProdutoCampanhaViewModel>();
var model = await _produtoCampanhaRepository.GetByCampaignIdAsync(id);
if (model == null)
{
return(response);
}
response.SetContent(_mapper.Map <ProdutoCampanhaViewModel>(model));
response.SetValid();
return(response);
}
public async Task <ResponseContract <UsuarioViewModel> > RegisterUpdateAsync(UsuarioViewModel viewModel)
{
var response = new ResponseContract <UsuarioViewModel>();
try
{
viewModel.RemoveFormatacao();
var model = await _usuarioRepository.FindAsync(_user.GetUserId());
model.SetRegisterUpdate(_mapper.Map <Usuario>(viewModel));
var valid = await _usuarioRepository.UpdateAsync(model);
if (!valid)
{
response.AddError(Resources.ErrorOnRegisterUpdate);
return(response);
}
var exist = await _enderecoAlteracaoRepository.ExistAsync(model.CampanhaId, model.UsuarioId);
if (!exist)
{
var enderecoAlteracao = new CampanhaUsuarioAtualizacaoCadastro
{
UsuarioId = model.UsuarioId,
CampanhaId = model.CampanhaId
};
await _enderecoAlteracaoRepository.InsertAsync(enderecoAlteracao);
_logger.LogWarning($"[UsuarioId: {_user.GetUserDocument()}] [CPF: {_user.GetUserDocument()}] incluido na alteração de endereço pela primeira vez.");
}
_logger.LogWarning($"[UsuarioId: {_user.GetUserDocument()}] [CPF: {_user.GetUserDocument()}] realizou alteração no cadastro.");
response.SetContent(_mapper.Map <UsuarioViewModel>(model));
response.SetValid();
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
response.AddError(Resources.ErrorOnRegisterUpdate);
}
return(response);
}
public async Task <ResponseContract <ProdutoViewModel> > GetByIdAsnc(GetProductByIdRequest request)
{
var response = new ResponseContract <ProdutoViewModel>();
var result = await _produtoRepository.FindAsync(request.Id);
if (result == null)
{
return(response);
}
var vm = _mapper.Map <ProdutoViewModel>(result);
response.SetContent(vm);
response.SetValid();
return(response);
}
public async Task <ResponseContract <UsuarioViewModel> > GetUserAsync()
{
var response = new ResponseContract <UsuarioViewModel>();
try
{
var model = await _usuarioRepository.FindAsync(_user.GetUserId());
response.SetContent(_mapper.Map <UsuarioViewModel>(model));
response.SetValid();
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
return(response);
}
//[ValidateAntiForgeryToken]
public ActionResult Transferencia(Lancamentos lancamento)
{
ResponseContract <Lancamentos> response = new ResponseContract <Lancamentos>();
try
{
response.Data = lancamentoApp.Transferencia(lancamento);
response.StatusCode = 200;
return(Ok(response));
}
catch (Exception ex)
{
//Felipe: Tratei como bad request como exemplo
response.IsSuccess = false;
response.StatusCode = (int)HttpStatusCode.BadRequest;
response.error = ex.Message;
return(BadRequest(response));
}
}
public async Task <ResponseContract <CepTotalViewModel> > FindByZipCodeAsync(CepTotalRequest request)
{
var response = new ResponseContract <CepTotalViewModel>();
try
{
var vm = _mapper.Map <CepTotalViewModel>(await _cepTotalRepository.FindByZipCodeAsync(request.Cep.JustNumbers()));
if (vm == null)
{
return(response);
}
response.SetContent(vm);
response.SetValid();
return(response);
}
catch (System.Exception ex)
{
_logger.LogError(ex, ex.Message);
return(response);
}
}
public async Task <ResponseContract <LoginViewModel> > LoginAsync(LoginViewModel viewModel)
{
var response = new ResponseContract <LoginViewModel>();
try
{
var campanha = await _campanhaRepository.GetCurrentAsync(_campaignSettings.Name);
if (campanha == null)
{
response.AddError(Resources.CampaignInvalid);
return(response);
}
var usuario = await _usuarioRepository.GetByBirthDateAndDocumentAndCampaign(campanha.CampanhaId, viewModel.Cpf.RemoveFormatacao(), viewModel.DataNascimento);
if (usuario == null)
{
response.AddError(Resources.LoginInvalid);
return(response);
}
await GenerateClaimsAsync(usuario, campanha);
_logger.LogWarning($"[UsuarioId: {usuario.UsuarioId}] [CPF: {usuario.Documento}] realizou login com sucesso.");
await SetAccessControl(usuario);
response.SetValid();
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
response.AddError(Resources.ErrorOnLogin);
}
return(response);
}
public void UpdateOperationResponse()
{
string apiId = _apiId;
string operationId = _operationId;
APIOperation entity_v1 = Client.GetAPIOperationAsync(apiId, operationId).Result;
ResponseContract response = ResponseContract.Create(400, "Ok", null);
List <ResponseContract> responses = entity_v1.Responses.ToList();
responses.Add(response);
APIOperation operation = new APIOperation()
{
Responses = responses.ToArray()
};
var task = Client.UpdateAPIOperationAsync(apiId, operationId, operation);
task.Wait();
APIOperation entity_v2 = Client.GetAPIOperationAsync(apiId, operationId).Result;
Assert.AreEqual(entity_v2.Responses.Count(), operation.Responses.Count());
}
public void UpdateOperationResponse()
{
string apiId = "api_b8aad5c90425479c9e50c2513bfbc804";
string operationId = "operation_ab7e97314cb840eca6cead919d7c003b";
APIOperation entity_v1 = Client.GetAPIOperationAsync(apiId, operationId).Result;
ResponseContract response = ResponseContract.Create(400, "Ok", null);
List <ResponseContract> responses = entity_v1.Responses.ToList();
responses.Add(response);
APIOperation operation = new APIOperation()
{
Responses = responses.ToArray()
};
var task = Client.UpdateAPIOperationAsync(apiId, operationId, operation);
task.Wait();
APIOperation entity_v2 = Client.GetAPIOperationAsync(apiId, operationId).Result;
Assert.AreEqual(entity_v2.Responses.Count(), operation.Responses.Count());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
ILogger log,
ExecutionContext context)
{
try
{
EnsureClient(context);
string productCode = req.Query["productCode"];
SqlQuerySpec querySpec = null;
if (!String.IsNullOrWhiteSpace(productCode))
{
querySpec = new SqlQuerySpec(
String.Concat(
"SELECT VALUE COUNT(1) FROM Items i WHERE i.productCode IN ('",
productCode,
"')"));
}
else
{
querySpec = new SqlQuerySpec("SELECT VALUE COUNT(1)FROM Items i");
}
IDocumentQuery <dynamic> query = cosmosDbClient.CreateDocumentQuery(
collectionUri,
querySpec,
new FeedOptions()
{
EnableCrossPartitionQuery = true,
PartitionKey = null,
PopulateQueryMetrics = true,
MaxItemCount = 50,
MaxDegreeOfParallelism = 0,
MaxBufferedItemCount = 100
}).AsDocumentQuery();
double totalRUs = 0;
long count = 0;
while (query.HasMoreResults)
{
FeedResponse <dynamic> feedResponse = await query.ExecuteNextAsync();
Console.WriteLine(feedResponse.RequestCharge);
totalRUs += feedResponse.RequestCharge;
IReadOnlyDictionary <string, QueryMetrics> partitionIdToQueryMetrics = feedResponse.QueryMetrics;
foreach (KeyValuePair <string, QueryMetrics> kvp in partitionIdToQueryMetrics)
{
string partitionId = kvp.Key;
QueryMetrics queryMetrics = kvp.Value;
Console.WriteLine("{0}: {1}", partitionId, queryMetrics);
}
IEnumerator <dynamic> docEnumerator = feedResponse.GetEnumerator();
while (docEnumerator.MoveNext())
{
count += (long)docEnumerator.Current;
}
}
var responsePayload = new ResponseContract
{
Count = count,
TotalRUs = totalRUs,
};
log.LogInformation("Count: {0}, Total RUs: {1}", count, totalRUs);
return(new OkObjectResult(JsonConvert.SerializeObject(responsePayload)));
}
catch (Exception error)
{
return(new ObjectResult(error.ToString())
{
StatusCode = 500
});
}
}
