public async Task <JsonResult> OnPostGetDataFromEntiy([FromBody] Entity Bank)
{
var token = HttpContext.Session.GetString("token");
var o = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
filterInvoice Entity = new filterInvoice();
Entity.Id = Bank.Person.Id;
var respuesta = await _pS.RegisterById(new ParamProspecto { Filter = Entity, Country = Int32.Parse(o) });
if (respuesta.Error == null)
{
var id = User.Claims.Where(x => x.Type == "Id").Select(x => x.Value).SingleOrDefault();
var l = await this._aS.RefreshToken(id, CultureInfo.CurrentCulture.Name, "BACKOFFICE", token);
if (l.Error == null)
{
HttpContext.Session.SetString("token", l.Token);
}
}
return(new JsonResult(respuesta));
}
public async Task <IActionResult> OnGetAsync()
{
var token = HttpContext.Session.GetString("token");
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
if (token == null || token == "" || token == "null" || Owner == null)
{
return(RedirectToPage("/logout"));
}
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Discriminator = User.Claims.Where(x => x.Type == "Discriminator").Select(x => x.Value).SingleOrDefault();
TipoParticipante = Participant;
if (Participant == "DEBTOR")
{
NRol = 1;
}
else if (Participant == "SUPPLIER")
{
NRol = 2;
}
registrarClienteTF.User = new User();
registrarClienteTF.Registrarse = new PesonProfile();
registrarClienteTF.User.Participant = Participant;
registrarClienteTF.User.Discriminator = Discriminator;
if (HttpContext.Session.GetString("CountryPerfil") == null || HttpContext.Session.GetString("CountryPerfil") == "null" || HttpContext.Session.GetString("CountryPerfil") == "")
{
registrarClienteTF.DataPaises = await _globalService.ConsultasAsociadosTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]) });
HttpContext.Session.SetString("CountryPerfil", JsonConvert.SerializeObject(registrarCliente.DataPaises));
}
else
{
registrarClienteTF.DataPaises = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryPerfil"));
}
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = Owner;
registrarClienteTF.Perfil = await _peopleService.ConsultaAsociados(new ParamProspecto { Filter = PeopleId, Country = int.Parse(Country) });
if (registrarClienteTF.Perfil.Error == null)
{
var id = User.Claims.Where(x => x.Type == "Id").Select(x => x.Value).SingleOrDefault();
var l = await _aS.RefreshToken(id, CultureInfo.CurrentCulture.Name, Participant, token, Confirmant);
if (l.Error == null)
{
HttpContext.Session.SetString("token", l.Token);
}
}
RellenarPerfil();
registrarClienteTF.AuthRol = (await _AuthorizationService.AuthorizeAsync(User, "PolicyProfileChange")).Succeeded;
registroJson = JsonConvert.SerializeObject(registrarClienteTF);
return(Page());
}
public async Task <JsonResult> OnPostVerificarDocActualizar([FromBody] Persons comprobarDocA)
{
Prospecto regsitro = null;
Associate contact = new Associate();
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
var token = HttpContext.Session.GetString("token");
var respuesta = await _peopleService.RegisterByDocument(new ParamProspecto
{
Document = new DocumentIdentification
{
Country = Int32.Parse(Request.Cookies["Country"]),
Identification = comprobarDocA.Document.Identification,
Prefix = comprobarDocA.Document.Prefix,
Number = comprobarDocA.Document.Number,
}
});
try
{
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = respuesta.Person;
regsitro = await _peopleService.RegisterById(new ParamProspecto { Filter = PeopleId, Country = Int32.Parse(Request.Cookies["Country"]) });
contact.Person = regsitro.Id;
contact.Company = regsitro.Company;
if (regsitro.Documents != null)
{
contact.Prefix = regsitro.Documents[0].Prefix;
contact.Identification = regsitro.Documents[0].Identification;
contact.Number = regsitro.Documents[0].Number;
}
if (regsitro.Contacts != null)
{
foreach (var contacto in regsitro.Contacts)
{
if (contacto.Label == "LEGAL")
{
contact.Name = contacto.Name;
contact.Email = contacto.Email;
contact.PhoneNumber = contacto.PhoneNumber;
}
}
}
if (regsitro.Agreements != null)
{
foreach (var iden in regsitro.Agreements)
{
//if (Participant == iden.Participant) contact.State = "igual";
}
}
return(new JsonResult(contact));
}
catch { return(null); }
}
public async Task <List <Publications> > GetCandidates(string owner, filterInvoice filter = null, Pagination pagination = null, string token = "", string participant = null)
{
try
{
return(await this._consumer.GetCandidates(owner, filter, pagination, token, participant));
}catch (Exception)
{
return(new List <Publications>());
}
}
public async Task <JsonResult> OnPostGroups([FromBody] filterInvoice filter)
{
var token = HttpContext.Session.GetString("token");
var o = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
var groups = await this._aS.GetGroups(Int32.Parse(o), token, filter);
return(new JsonResult(groups));
}
public async Task <List <Publications> > GetWinner(int idPais, string owner, filterInvoice filter = null, Pagination pagination = null, string token = "")
{
try
{
return(await this._consumer.GetWinner(idPais, owner, filter, pagination, token));
}catch (Exception)
{
return(new List <Publications>());
}
}
public async Task <List <Invoices> > GetPostponed(string owner, filterInvoice filter = null, Pagination pagination = null, string token = "")
{
try
{
return(await this._consumer.GetPostponed(owner, filter, pagination, token));
}
catch (Exception)
{
return(new List <Invoices>());
}
}
public async Task <List <Financiable> > GetFinanciables(string idClient, filterInvoice filter = null, Pagination pagination = null, string token = "")
{
try
{
return(await this._consumer.GetFinanciables(idClient, filter, pagination, token));
}
catch (Exception)
{
return(new List <Financiable>());
}
}
public async Task <JsonResult> OnPostCancelInvitation([FromBody] ParamGuests Invitado)
{
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Invitado.Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Invitado.Person = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
var token = HttpContext.Session.GetString("token");
var respuesta = await _peopleService.CancelInvitation(Invitado, token);
if (respuesta.Error == null)
{
var id = User.Claims.Where(x => x.Type == "Id").Select(x => x.Value).SingleOrDefault();
var l = await _aS.RefreshToken(id, CultureInfo.CurrentCulture.Name, Participant, token, Confirmant);
if (l.Error == null)
{
HttpContext.Session.SetString("token", l.Token);
}
}
if (respuesta.Error == null || respuesta.Error == "")
{
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Discriminator = User.Claims.Where(x => x.Type == "Discriminator").Select(x => x.Value).SingleOrDefault();
TipoParticipante = Participant;
registrarClienteTF.User = new User();
registrarClienteTF.Registrarse = new PesonProfile();
registrarClienteTF.User.Participant = Participant;
registrarClienteTF.User.Discriminator = Discriminator;
if (HttpContext.Session.GetString("CountryPerfil") == null || HttpContext.Session.GetString("CountryPerfil") == "null" || HttpContext.Session.GetString("CountryPerfil") == "")
{
registrarClienteTF.DataPaises = await _globalService.ConsultasAsociadosTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]) });
HttpContext.Session.SetString("CountryPerfil", JsonConvert.SerializeObject(registrarCliente.DataPaises));
}
else
{
registrarClienteTF.DataPaises = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryPerfil"));
}
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = Owner;
registrarClienteTF.Perfil = await _peopleService.ConsultaAsociados(new ParamProspecto { Filter = PeopleId, Country = int.Parse(Country) });
RellenarPerfil();
registrarClienteTF.AuthRol = (await _AuthorizationService.AuthorizeAsync(User, "PolicyProfileChange")).Succeeded;
return(new JsonResult(registrarClienteTF));
}
return(new JsonResult(new { error = respuesta.Error }));
}
public async Task <List <Group> > GetGroups(int country, string token, filterInvoice filter)
{
try
{
return(await _consumer.GetGroups(country, token, filter));
}
catch
{
throw;
}
}
public async Task <JsonResult> OnPostDetailtQuota()
{
var owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
var country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
var token = HttpContext.Session.GetString("token");
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = owner;
var data = await _pS.GetDetailQuotas(new ParamProspecto { Filter = PeopleId, Country = int.Parse(country) }, token);
return(new JsonResult(data));
}
//Contratos
public async Task <JsonResult> OnPostContrato([FromBody] AcceptanceAgreements agreementsContratoMarco)
{
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
Discriminator = User.Claims.Where(x => x.Type == "Discriminator").Select(x => x.Value).SingleOrDefault();
var token = HttpContext.Session.GetString("token");
agreementsContratoMarco.Person = Owner;
var respuesta = await _peopleService.MutacionContratoAsync(agreementsContratoMarco, token);
if (respuesta != null)
{
TipoParticipante = Participant;
registrarClienteTF.User = new User();
registrarClienteTF.Registrarse = new PesonProfile();
registrarClienteTF.User.Participant = Participant;
registrarClienteTF.User.Discriminator = Discriminator;
if (HttpContext.Session.GetString("CountryPerfil") == null || HttpContext.Session.GetString("CountryPerfil") == "null" || HttpContext.Session.GetString("CountryPerfil") == "")
{
registrarClienteTF.DataPaises = await _globalService.ConsultasCountryTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]) });
HttpContext.Session.SetString("CountryPerfil", JsonConvert.SerializeObject(registrarCliente.DataPaises));
}
else
{
registrarClienteTF.DataPaises = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryPerfil"));
}
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = Owner;
registrarClienteTF.Perfil = await _peopleService.RegisterById(new ParamProspecto { Filter = PeopleId, Country = int.Parse(Country) }, token);
if (registrarClienteTF.Perfil.Addresses != null)
{
registrarClienteTF.Cities = await _globalService.ConsultaCitiesTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]), Region = registrarClienteTF.Perfil.Addresses[0].Region });
}
RellenarPerfil();
registrarClienteTF.AuthRol = (await _AuthorizationService.AuthorizeAsync(User, "PolicyProfileChange")).Succeeded;
registrarClienteTF.ContratAuth = (await _AuthorizationService.AuthorizeAsync(User, "PolicyContracts")).Succeeded;
return(new JsonResult(registrarClienteTF));
}
else
{
return(new JsonResult(null));
}
}
public async Task <IActionResult> OnGetAsync()
{
filter = new filterInvoice()
{
IsOffered = null
};
OfferedNull = null;
var token = HttpContext.Session.GetString("token");
if (token == null)
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
dataToken = token;
dataFilter = JsonConvert.SerializeObject(filter);
var c = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
var o = Int32.Parse(User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault());
Currency_options = new List <SelectListItem>();
if (HttpContext.Session.GetString("CurrencyCountry") == null || JsonConvert.DeserializeObject <Country>(HttpContext.Session.GetString("CurrencyCountry")).Id != o)
{
var data = await this._gS.GetDataCountryCurrency(o, token);
if (data != null && data.Errors == this.__notAuthorized)
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
HttpContext.Session.SetString("CurrencyCountry", JsonConvert.SerializeObject(data));
}
foreach (var currency in JsonConvert.DeserializeObject <Country>(HttpContext.Session.GetString("CurrencyCountry")).Currencies)
{
Currency_options.Add(new SelectListItem()
{
Value = "" + currency.Id.Value, Text = currency.Name
});
}
dataJsonFactor = (string)JsonConvert.SerializeObject(c);
return(Page());
}
public async Task <IActionResult> OnGetAsync()
{
var token = HttpContext.Session.GetString("token");
if (token == null || token == "" || token == "null")
{
return(RedirectToPage("/logout"));
}
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
User Contrato = new User();
Contrato.Person = new Prospecto();
if (Participant == "DEBTOR")
{
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = Owner;
var contratoTerminos = await _peopleService.ConsultaContratoAsync(new ParamProspecto { Filter = PeopleId, Country = int.Parse(country), Participant = Participant }, token);
if (contratoTerminos != null && contratoTerminos.Agreements != null)
{
foreach (var contrato in contratoTerminos.Agreements)
{
Contrato.Person.Agreements.Add(contrato);
}
}
}
var data = await this._globalService.GetDataCountryInvoices(Int32.Parse(country), token);
Country = data;
Contrato.Participant = Participant;
ContratoJson = JsonConvert.SerializeObject(Contrato);
#region RefreshToken
var id = User.Claims.Where(x => x.Type == "Id").Select(x => x.Value).SingleOrDefault();
var l = await this._aS.RefreshToken(id, CultureInfo.CurrentCulture.Name, "DEBTOR", token);
if (l.Error == null)
{
HttpContext.Session.SetString("token", l.Token);
}
#endregion
return(Page());
}
public async Task <IActionResult> OnGet()
{
var token = HttpContext.Session.GetString("token");
if (token == null)
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
filter = new filterInvoice();
this.filterData = JsonConvert.SerializeObject(filter);
return(Page());
}
public async Task <IViewComponentResult> InvokeAsync(Country country, string owner)
{
var token = HttpContext.Session.GetString("token");
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = owner;
var countryID = country == null ? 0 : country.Id;
var person = await _peopleService.GetDetailQuotas(new ParamProspecto { Filter = PeopleId, Country = (int)countryID }, token);
var modelo = new Modelo();
modelo.Country = country;
modelo.Person = person;
return(View("Default", modelo));
}
public async Task <IActionResult> OnPostLlenarConsultaAsync([FromBody] RequestPagination pag)
{
var token = HttpContext.Session.GetString("token");
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
var Estados = await _globalService.ConsultaIdentificationsAndCitiesTF(new ParamCountry { Id = Int32.Parse(Country) });
filterInvoice currencyAccountInvoiceFilter = new filterInvoice();
if (pag.Filter != null)
{
currencyAccountInvoiceFilter = pag.Filter;
}
Prospectos ListaClientesBanco = new Prospectos();
List <ListAccountantsInvoices> listaFinanciedInvoices = new List <ListAccountantsInvoices>();
if (Estados != null)
{
if (Estados.Currencies != null)
{
if (pag.Filter.AmountRiskFrom == null)
{
pag.Filter.AmountRiskFrom = 0;
}
if (pag.Filter.Abbreviation == null)
{
pag.Filter.Abbreviation = "CREDIT";
}
ListaClientesBanco = await _peopleService.GetConsultaFinaciamientoConfirmant(new ParamClienteOFConfirmant { Bank_id = Confirmant, Filter = pag.Filter, Pagination = pag.Pagination }, token);
var ListaAccountantsInvoices = await _invoiceService.GetFinanciablesBankInvoices(new ParamAccountantsInvoices { Country = Int32.Parse(Country), Confirmant = Confirmant }, currencyAccountInvoiceFilter, token);
ListaAccountantsInvoices.Currency = pag.Filter.Currency_id;
listaFinanciedInvoices.Add(ListaAccountantsInvoices);
}
}
return(new JsonResult(new { lista = ListaClientesBanco, estado = Estados, listaFinanciedInvoices = listaFinanciedInvoices }));
}
public async Task <IActionResult> OnGetAsync()
{
var token = HttpContext.Session.GetString("token");
if (token == null || token == "" || token == "null")
{
return(RedirectToPage("/logout"));
}
filter = new filterInvoice()
{
Financied = null
};
dataFilter = JsonConvert.SerializeObject(filter);
financiedNull = null;
TipoParticipante = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Debtor_Options = new List <SelectListItem>();
Email_options = new List <SelectListItem>();
Currency_options = new List <SelectListItem>();
//----------- Llenado de Country
if (HttpContext.Session.GetString("CountryIdentifications") == null ||
HttpContext.Session.GetString("CountryIdentifications") == "" ||
HttpContext.Session.GetString("CountryIdentifications") == "null")
{
Identifications = await _globalService.ConsultasCountryTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]) });
HttpContext.Session.SetString("CountryIdentifications", JsonConvert.SerializeObject(Identifications));
}
else
{
Identifications = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryIdentifications"));
}
//----------- Llenado de Country
listadosInicialesJson = JsonConvert.SerializeObject(Identifications);
return(Page());
}
public async Task <JsonResult> OnPost([FromBody] Persons registroGuardar)
{
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
Discriminator = User.Claims.Where(x => x.Type == "Discriminator").Select(x => x.Value).SingleOrDefault();
var Auth = (await _AuthorizationService.AuthorizeAsync(User, "PolicyProfileChange")).Succeeded;
string Err = null;
var token = HttpContext.Session.GetString("token");
registrarClienteTF.User = new User();
registrarClienteTF.Registrarse = new PesonProfile();
registrarClienteTF.User.Participant = Participant;
registrarClienteTF.User.Discriminator = Discriminator;
Profiles PerfilUser = new Profiles();
registroGuardar.Address.Country = int.Parse(Country);
registroGuardar.Address.Label = "LEGAL";
if (registroGuardar.Phone != null)
{
registroGuardar.Phone.Country = int.Parse(Country);
}
PerfilUser.Id = Owner;
PerfilUser.Country = int.Parse(Country);
//PerfilUser.Company = registroGuardar.Company;
PerfilUser.Addresses.Add(registroGuardar.Address);
if (registroGuardar.Contacts != null)
{
foreach (var Contacto in registroGuardar.Contacts)
{
if (Contacto.Label != "LEGAL")
{
PerfilUser.Contacts.Add(Contacto);
}
else
{
Contact Representante = JsonConvert.DeserializeObject <Contact>(HttpContext.Session.GetString("RepresentanteLegal"));
Representante.PhoneNumber = Contacto.PhoneNumber;
if (Representante != null && Representante.Id != null && Representante.Id != "")
{
PerfilUser.Contacts.Add(Representante);
}
}
}
}
//PerfilUser.Contacts = registroGuardar.Contacts;
PerfilUser.Discriminator = registroGuardar.Discriminator;
//PerfilUser.Documents.Add(registroGuardar.Document);
if (registroGuardar.Email != null)
{
PerfilUser.Emails.Add(registroGuardar.Email);
}
//PerfilUser.FirstName = registroGuardar.FirstName;
//PerfilUser.LastName = registroGuardar.LastName;
PerfilUser.Participant = registroGuardar.Participant;
//PerfilUser.Phones.Add(registroGuardar.Phone);
//PerfilUser.Category = registroGuardar.Category;
if (registroGuardar.Accounts != null)
{
PerfilUser.Accounts = registroGuardar.Accounts;
}
registrarClienteTF.Perfil = await _peopleService.UpdateProfileTF(PerfilUser, token);
if (registrarClienteTF.Perfil.Error == null)
{
var id = User.Claims.Where(x => x.Type == "Id").Select(x => x.Value).SingleOrDefault();
var l = await _aS.RefreshToken(id, CultureInfo.CurrentCulture.Name, Participant, token, Confirmant);
if (l.Error == null)
{
HttpContext.Session.SetString("token", l.Token);
}
}
if (registrarClienteTF.Perfil.Error != null)
{
Err = registrarClienteTF.Perfil.Error;
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = Owner;
registrarClienteTF.Perfil = await _peopleService.RegisterById(new ParamProspecto { Participant = Participant, Filter = PeopleId, Country = int.Parse(Country) }, token);
}
if (HttpContext.Session.GetString("CountryPerfil") == null || HttpContext.Session.GetString("CountryPerfil") == "null" || HttpContext.Session.GetString("CountryPerfil") == "")
{
registrarClienteTF.DataPaises = await _globalService.ConsultasCountryTF(new ParamCountry { Id = int.Parse(Country) });
HttpContext.Session.SetString("CountryPerfil", JsonConvert.SerializeObject(registrarCliente.DataPaises));
}
else
{
registrarClienteTF.DataPaises = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryPerfil"));
}
if (registrarClienteTF.Perfil.Addresses != null)
{
registrarClienteTF.Cities = await _globalService.ConsultaCitiesTF(new ParamCountry { Id = int.Parse(Country), Region = registrarClienteTF.Perfil.Addresses[0].Region });
}
RellenarPerfil();
registrarClienteTF.AuthRol = Auth;
registrarClienteTF.ContratAuth = (await _AuthorizationService.AuthorizeAsync(User, "PolicyContracts")).Succeeded;
return(new JsonResult(new { error = Err, person = registrarClienteTF }));
}
public async Task <JsonResult> OnPostDetalleCliente([FromBody] Prospecto person)
{
DetallesClientes detallesClientes = new DetallesClientes();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
ListCountry Pais = new ListCountry();
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = person.Id;
person = await _peopleService.RegisterById(new ParamProspecto { Filter = PeopleId, Country = int.Parse(Country) });
if (person.Error == null)
{
detallesClientes.Error = person.Error;
var id = User.Claims.Where(x => x.Type == "Id").Select(x => x.Value).SingleOrDefault();
var l = await _aS.RefreshToken(id, CultureInfo.CurrentCulture.Name, Participant, token);
if (l.Error == null)
{
HttpContext.Session.SetString("token", l.Token);
}
}
if (person.Addresses != null)
{
Pais = await _globalService.ConsultaIdentificationsAndCitiesTF(new ParamCountry { Id = int.Parse(Country), Region = person.Addresses[0].Region });
}
if (Pais.Identifications != null)
{
foreach (var iden in Pais.Identifications)
{
if (person.Documents != null)
{
if (iden.Id == person.Documents[0].Identification && iden.Prefix == false)
{
detallesClientes.Document.Abbreviation = iden.Abbreviation;
detallesClientes.Document.Number = person.Documents[0].Number;
}
else if (iden.Id == person.Documents[0].Identification && iden.Prefix == true)
{
foreach (var prefx in iden.Prefixes)
{
if (prefx.Id == person.Documents[0].Prefix)
{
detallesClientes.Document.Abbreviation = prefx.Abbreviation;
detallesClientes.Document.Number = person.Documents[0].Number;
}
}
}
}
if (person.Contacts != null)
{
foreach (var contacto in person.Contacts)
{
if (contacto.Label == "LEGAL")
{
detallesClientes.Representante.DocumentNumber = contacto.DocumentNumber;
detallesClientes.Representante.Name = contacto.Name;
detallesClientes.Representante.PhoneNumber = contacto.PhoneNumber;
detallesClientes.Representante.Email = contacto.Email;
if (iden.Id == contacto.Identification && iden.Prefix == false)
{
detallesClientes.Representante.Label = iden.Abbreviation;
}
else if (iden.Id == contacto.Identification && iden.Prefix == true)
{
foreach (var prefx in iden.Prefixes)
{
if (prefx.Id == contacto.Prefix)
{
detallesClientes.Representante.Label = prefx.Abbreviation;
}
}
}
}
else if (contacto.Label == "CONTACT")
{
detallesClientes.Contacto.DocumentNumber = contacto.DocumentNumber;
detallesClientes.Contacto.Name = contacto.Name;
detallesClientes.Contacto.PhoneNumber = contacto.PhoneNumber;
detallesClientes.Contacto.Email = contacto.Email;
if (iden.Id == contacto.Identification && iden.Prefix == false)
{
detallesClientes.Contacto.Label = iden.Abbreviation;
}
else if (iden.Id == contacto.Identification && iden.Prefix == true)
{
foreach (var prefx in iden.Prefixes)
{
if (prefx.Id == contacto.Prefix)
{
detallesClientes.Contacto.Label = prefx.Abbreviation;
}
}
}
}
}
}
}
}
if (Pais.Regions != null)
{
foreach (var city in Pais.Regions[0].Cities)
{
if (person.Addresses[0].City == city.Id)
{
detallesClientes.Address.Region = Pais.Regions[0].Name;
detallesClientes.Address.City = city.Name;
continue;
}
}
}
detallesClientes.Company = person.Company;
if (person.Phones != null)
{
detallesClientes.Phone = person.Phones[0].Number;
}
else
{
detallesClientes.Phone = null;
}
if (person.Addresses != null)
{
detallesClientes.Address.Line1 = person.Addresses[0].Line1;
detallesClientes.Address.Line2 = person.Addresses[0].Line2;
}
if (detallesClientes.Contacto.DocumentNumber == null || detallesClientes.Contacto.DocumentNumber == "")
{
detallesClientes.Contacto = null;
}
if (person.Discriminator == "PERSON")
{
detallesClientes.Company = person.FirstName;
/*
* detallesClientes.Representante.Label = detallesClientes.Document.Abbreviation;
* detallesClientes.Representante.DocumentNumber = detallesClientes.Document.Number;
* detallesClientes.Representante.Name = person.FirstName;
* detallesClientes.Representante.PhoneNumber = person.Phones[0].Number;
*/
if (person.Emails != null)
{
detallesClientes.Email = person.Emails[0].Address;
}
detallesClientes.Representante = null;
detallesClientes.Contacto = null;
}
return(new JsonResult(detallesClientes));
}
public async Task <IActionResult> OnGetAsync()
{
var token = HttpContext.Session.GetString("token");
if (token == null || token == "" || token == "null")
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
filter = new filterInvoice()
{
Financied = false
};
dataFilter = JsonConvert.SerializeObject(filter);
financiedNull = null;
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
//----------- Llenado de Country
if (HttpContext.Session.GetString("CountryIdentifications") == null ||
HttpContext.Session.GetString("CountryIdentifications") == "" ||
HttpContext.Session.GetString("CountryIdentifications") == "null")
{
Identifications = await _globalService.ConsultaRegiosAndCitiesTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]) });
HttpContext.Session.SetString("CountryIdentifications", JsonConvert.SerializeObject(Identifications));
}
else
{
Identifications = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryIdentifications"));
}
//----------- Llenado de Country
City_Options = new List <SelectListItem>();
Status_Options = new List <SelectListItem>();
Status_Options.Add(new SelectListItem()
{
Value = "0", Text = "Activo"
});
Status_Options.Add(new SelectListItem()
{
Value = "1", Text = "Bloqueado"
});
Discriminator_options = new List <SelectListItem>();
Discriminator_options.Add(new SelectListItem()
{
Value = "LEGAL", Text = "Persona Legal"
});
Discriminator_options.Add(new SelectListItem()
{
Value = "PERSON", Text = "Persona Natural"
});
Participant_options = new List <SelectListItem>()
{
new SelectListItem()
{
Value = "DEBTOR", Text = "EMPRESAS"
},
new SelectListItem()
{
Value = "SUPPLIER", Text = "PROVEEDORES"
},
new SelectListItem()
{
Value = "FACTOR", Text = "INVERSIONISTAS"
}
};
//Para llenar El filtro de Estados
State_Options = new List <SelectListItem>();
foreach (var state in Identifications.Regions)
{
State_Options.Add(new SelectListItem()
{
Value = state.id.ToString(), Text = state.Name
});
}
State_Options.Sort((a, b) => a.Text.CompareTo(b.Text));
listadosInicialesJson = JsonConvert.SerializeObject(Identifications);
return(Page());
}
public async Task <IActionResult> OnGetAsync()
{
get = true;
filter = new filterInvoice()
{
Financied = null,
};
var token = HttpContext.Session.GetString("token");
if (token == null)
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
dataFilter = JsonConvert.SerializeObject(filter);
financiedNull = null;
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
if (HttpContext.Session.GetString("CountryInvoicesProgram") == null || JsonConvert.DeserializeObject <Country>(HttpContext.Session.GetString("CountryInvoicesProgram")).Id != Int32.Parse(Country))
{
var data = await _globalService.GetDataCountryInvoices(Int32.Parse(Country), token);
if (data.Errors == this.__notAuthorized)
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
HttpContext.Session.SetString("CountryInvoicesProgram", JsonConvert.SerializeObject(data));
}
List <Invoices> facturaCheck = new List <Invoices>();
Supplier_Options = new List <SelectListItem>();
Debtor_Options = new List <SelectListItem>();
Currency_options = new List <SelectListItem>();
Status_Options = new List <SelectListItem>();
Programs_Options = new List <SelectListItem>();
ListStatus();
List <ResponseProveedores> clientes = null;
clientes = await _peopleService.GetDeptors(Owner, token);
if (clientes.Count > 0 && clientes[0].Errors == this.__notAuthorized)
{
return(RedirectToPage("/logout", "session expired", new { returnUrl = "~/index?error=sessionExpired" }));
}
foreach (var cls in clientes)
{
if (!Debtor_Options.Exists(x => x.Value == cls.Id))
{
Debtor_Options.Add(new SelectListItem()
{
Value = cls.Id, Text = cls.Name
});
}
}
foreach (var currency in JsonConvert.DeserializeObject <Country>(HttpContext.Session.GetString("CountryInvoicesProgram")).Currencies)
{
Currency_options.Add(new SelectListItem()
{
Value = "" + currency.Id.Value, Text = currency.Name
});
}
foreach (var program in JsonConvert.DeserializeObject <Country>(HttpContext.Session.GetString("CountryInvoicesProgram")).Program)
{
if (!Programs_Options.Exists(x => x.Text == program.Abbreviation))
{
Programs_Options.Add(new SelectListItem()
{
Value = "" + program.Abbreviation, Text = program.Abbreviation
});
}
}
return(Page());
}
public async Task <List <Invoices> > GetInvoicesSupplier(ParametersDebtorEdition parameters, string tipo, filterInvoice filter = null, Pagination pagination = null, string token = "", string order = null, string group = null)
{
try
{
return(await this._consumer.GetInvoicesSupplier(parameters, tipo, filter, pagination, token, order, group));
}
catch (Exception)
{
return(new List <Invoices>());
}
}
public async Task <IActionResult> OnGetAsync()
{
var token = HttpContext.Session.GetString("token");
Owner = User.Claims.Where(x => x.Type == "Owner").Select(x => x.Value).SingleOrDefault();
if (token == null || token == "" || token == "null" || Owner == null)
{
return(RedirectToPage("/logout"));
}
Confirmant = User.Claims.Where(x => x.Type == "Confirmant").Select(x => x.Value).SingleOrDefault();
Participant = User.Claims.Where(x => x.Type == "Participant").Select(x => x.Value).SingleOrDefault();
Country = User.Claims.Where(x => x.Type == "Country").Select(x => x.Value).SingleOrDefault();
Discriminator = User.Claims.Where(x => x.Type == "Discriminator").Select(x => x.Value).SingleOrDefault();
var Auth = (await _AuthorizationService.AuthorizeAsync(User, "PolicyProfileChange")).Succeeded;
var AuthRol = User.IsInRole("LEGAL");
TipoParticipante = Participant;
switch (Participant)
{
case "CONFIRMANT":
NRol = 5; break;
case "DEBTOR":
NRol = 1; break;
case "FACTOR":
NRol = 3; break;
case "SUPPLIER":
NRol = 2; break;
case "BACKOFFICE":
NRol = 6; break;
}
registrarClienteTF.User = new User();
registrarClienteTF.Registrarse = new PesonProfile();
registrarClienteTF.User.Participant = Participant;
registrarClienteTF.User.Discriminator = Discriminator;
if (HttpContext.Session.GetString("CountryPerfil") == null || HttpContext.Session.GetString("CountryPerfil") == "null" || HttpContext.Session.GetString("CountryPerfil") == "")
{
registrarClienteTF.DataPaises = await _globalService.ConsultasCountryTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]) });
HttpContext.Session.SetString("CountryPerfil", JsonConvert.SerializeObject(registrarCliente.DataPaises));
}
else
{
registrarClienteTF.DataPaises = JsonConvert.DeserializeObject <ListCountry>(HttpContext.Session.GetString("CountryPerfil"));
}
filterInvoice PeopleId = new filterInvoice();
PeopleId.Id = Owner;
registrarClienteTF.Perfil = await _peopleService.RegisterById(new ParamProspecto { Participant = Participant, Filter = PeopleId, Country = int.Parse(Country) }, token);
if (registrarClienteTF.Perfil.Addresses != null)
{
registrarClienteTF.Cities = await _globalService.ConsultaCitiesTF(new ParamCountry { Id = Int32.Parse(Request.Cookies["Country"]), Region = registrarClienteTF.Perfil.Addresses[0].Region });
}
if (registrarClienteTF.Perfil != null && registrarClienteTF.Perfil.Contacts != null && registrarClienteTF.Perfil.Contacts.Count > 0)
{
foreach (var legal in registrarClienteTF.Perfil.Contacts)
{
if (legal.Label == "LEGAL")
{
HttpContext.Session.SetString("RepresentanteLegal", JsonConvert.SerializeObject(legal));
}
}
}
RellenarPerfil();
registrarClienteTF.AuthRol = Auth;
registrarClienteTF.ContratAuth = (await _AuthorizationService.AuthorizeAsync(User, "PolicyContracts")).Succeeded;
registroJson = JsonConvert.SerializeObject(registrarClienteTF);
return(Page());
}
//Payment Query for Confirmant
public async Task <List <Receipts> > ReceiptsQueryConfirmant(ParamConsultaPeyments param, filterInvoice filter = null, Pagination pagination = null, string token = "")
{
try
{
return(await _consumer.ReceiptsQueryConfirmant(param, filter, pagination, token));
}
catch
{
return(null);
}
}
//Payment Query for Backoffice
public async Task <List <Receipts> > ReceiptsQueryBackoffice(string state, string country, filterInvoice filter = null, Pagination pagination = null, string token = "")
{
try
{
return(await _consumer.ReceiptsQueryBackoffice(state, country, filter, pagination, token));
}
catch
{
return(null);
}
}
public async Task <List <Invoices> > GetInvoicesConsultas(string owner, string participant, filterInvoice filter = null, Pagination pagination = null)
{
try
{
return(null);
}
catch (Exception)
{
return(new List <Invoices>());
}
}
public async Task <List <Publications> > GetPublications(int country, string participant, string owner = null, filterInvoice filter = null, string token = "", Pagination pagination = null)
{
try
{
return(await this._consumer.GetPublications(country, participant, owner, filter, token, pagination));
}
catch (Exception)
{
return(new List <Publications>());
}
}
public async Task <List <Publications> > GetPublishable(string owner, string type, filterInvoice filter = null, Pagination pagination = null, string token = "")
{
try
{
return(await this._consumer.GetPublishable(owner, type, filter, pagination, token));
}
catch (Exception)
{
return(new List <Publications>());
}
}
public async Task <List <Publications> > GetPublicationsSessions(string owner, int country, filterInvoice filter = null, Pagination pagination = null, string token = null)
{
try
{
return(await this._consumer.GetPublicationsSessions(owner, country, filter, pagination, token));
}
catch (Exception)
{
return(new List <Publications>());
}
}
