public string CriarCanaisVerdesConta(string organizationName, string contaId, string familiasIds)
{
string[] lstRegitrosId = familiasIds.Split(';');
CanalVerdeService canalVerdeService = new CanalVerdeService(organizationName, false);
RepositoryService RepositoryService = new RepositoryService(organizationName, false);
DomainExecuteMultiple multipleCreateReturn = null;
var jsSerializer = new JavaScriptSerializer();
try
{
List <CanalVerde> canalVerdeList = new List <CanalVerde>();
foreach (var familiaIdTmp in lstRegitrosId)
{
string[] segmentoEFamiliaIdsLst = familiaIdTmp.Split('|');
CanalVerde canalVerdeTmp = new CanalVerde(organizationName, false);
canalVerdeTmp.Segmento = new Lookup(new Guid(segmentoEFamiliaIdsLst[0]), "");
canalVerdeTmp.FamiliaProduto = new Lookup(new Guid(segmentoEFamiliaIdsLst[1]), "");
canalVerdeTmp.Canal = new Lookup(new Guid(contaId), "");
canalVerdeList.Add(canalVerdeTmp);
}
multipleCreateReturn = RepositoryService.CanalVerde.Create(canalVerdeList);
}
catch (Exception e)
{
jsSerializer.MaxJsonLength = Int32.MaxValue;
Dictionary <string, string> retornoMapErr = new Dictionary <string, string>();
retornoMapErr.Add("return", "FALSE");
retornoMapErr.Add("message", e.Message);
var jsonErr = jsSerializer.Serialize(retornoMapErr);
return(jsonErr.ToString());
}
jsSerializer.MaxJsonLength = Int32.MaxValue;
Dictionary <string, string> retornoMap = new Dictionary <string, string>();
if (multipleCreateReturn.IsFaulted)
{
retornoMap.Add("return", "FALSE");
}
else
{
retornoMap.Add("return", "TRUE");
}
var json = jsSerializer.Serialize(retornoMap);
return(json.ToString());
}
public virtual DomainExecuteMultiple Create(List <T> collection)
{
ExecuteMultipleRequest request = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = false
},
Requests = new OrganizationRequestCollection()
};
foreach (T entity in collection)
{
var ent = EntityConvert.Convert <T>(entity, this.OrganizationName, this.IsOffline);
request.Requests.Add(new CreateRequest()
{
Target = ent, RequestId = ent.Id
});
}
ExecuteMultipleResponse responseWithResults = (ExecuteMultipleResponse)this.Provider.Execute(request);
DomainExecuteMultiple domainExecuteMultiple = new DomainExecuteMultiple();
domainExecuteMultiple.IsFaulted = responseWithResults.IsFaulted;
domainExecuteMultiple.List = new DomainExecuteMultipleItem[collection.Count];
foreach (var item in responseWithResults.Responses)
{
domainExecuteMultiple.List[item.RequestIndex] = new DomainExecuteMultipleItem()
{
ID = request.Requests[item.RequestIndex].RequestId.Value,
IsFaulted = (item.Fault != null),
Message = (item.Fault == null) ? null : item.Fault.Message
};
}
return(domainExecuteMultiple);
}
private List <string> AtualizarValoresPotencialProdutoMes(MetadaUnidade metaUnidade, int quantidadePorLote, Enum.OrcamentodaUnidade.Trimestres trimeste)
{
var listaPotencialProduto = RepositoryService.MetadaUnidadeporProduto.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);
var listaError = new List <string>();
var listaCreate = new List <MetaDetalhadadaUnidadeporProduto>();
var listaUpdate = new List <MetaDetalhadadaUnidadeporProduto>();
foreach (var mes in Helper.ListarMeses(trimeste))
{
var listaTodos = RepositoryService.MetadaUnidadeporProdutoMes.ListarValoresPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, mes);
var listaExistentes = RepositoryService.MetadaUnidadeporProdutoMes.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, mes);
foreach (var item in listaTodos)
{
var itemExistente = listaExistentes.Find(x => x.Produto.Id == item.Produto.Id);
if (itemExistente == null)
{
var potencialProduto = listaPotencialProduto.Find(x => x.Produto.Id == item.Produto.Id);
item.Nome = string.Format("{0} - {1} - {2}", metaUnidade.UnidadedeNegocios.Name, Helper.ConvertToInt(mes), item.Produto.Name).Truncate(100);
item.MetadoProduto = new Lookup(potencialProduto.ID.Value, potencialProduto.Nome, SDKore.Crm.Util.Utility.GetEntityName(potencialProduto));
item.Trimestre = (int)trimeste;
item.UnidadeNegocio = metaUnidade.UnidadedeNegocios;
item.RazaoStatus = (int)Domain.Enum.MetaUnidadeporProdutoMes.StatusCode.Ativa;
listaCreate.Add(item);
}
else
{
item.ID = itemExistente.ID;
listaUpdate.Add(item);
}
}
}
// Update em lote
for (int i = 0; i < listaUpdate.Count; i += quantidadePorLote)
{
var retorno = RepositoryService.MetadaUnidadeDetalhadaProduto.Update(listaUpdate.Skip(i).Take(quantidadePorLote).ToList());
foreach (var item in retorno)
{
listaError.Add(item.Key + " - " + item.Value);
}
}
// Create em lote
for (int i = 0; i < listaCreate.Count; i += quantidadePorLote)
{
var listaEmLote = listaCreate.Skip(i).Take(quantidadePorLote).ToList();
DomainExecuteMultiple retorno = RepositoryService.MetadaUnidadeDetalhadaProduto.Create(listaEmLote);
if (retorno.IsFaulted)
{
for (int x = 0; x < retorno.List.Length; x++)
{
var item = retorno.List[x];
listaError.Add("Create - " + item.Message);
}
}
}
return(listaError);
}
private List <string> AtualizarValoresPotencialSubfamilia(MetadaUnidade metaUnidade, int quantidadePorLote, Enum.OrcamentodaUnidade.Trimestres?trimeste)
{
var listaTodos = RepositoryService.MetadaUnidadeporSubfamilia.ListarValoresPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);
var listaExistentes = RepositoryService.MetadaUnidadeporSubfamilia.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);
var listaPotencialFamilia = RepositoryService.MetadaUnidadeporFamilia.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);
var listaError = new List <string>();
var listaCreate = new List <MetadaUnidadeporSubfamilia>();
var listaUpdate = new List <MetadaUnidadeporSubfamilia>();
foreach (var item in listaTodos)
{
var itemExistente = listaExistentes.Find(x => x.Trimestre.Value == item.Trimestre.Value &&
x.Subfamilia.Id == item.Subfamilia.Id);
if (itemExistente == null)
{
var potencialFamilia = listaPotencialFamilia.Find(x => x.Trimestre.Value == item.Trimestre.Value &&
x.Familia.Id == item.Familia.Id);
item.UnidadedeNegocio = metaUnidade.UnidadedeNegocios;
item.Ano = metaUnidade.Ano;
item.Nome = string.Format("{0} - {1}", metaUnidade.UnidadedeNegocios.Name, item.Subfamilia.Name);
item.MetadaFamilia = new Lookup(potencialFamilia.ID.Value, potencialFamilia.Nome, SDKore.Crm.Util.Utility.GetEntityName(potencialFamilia));
item.RazaoStatus = (int)Domain.Enum.MetaUnidadeporSubfamilia.StatusCode.Ativa;
listaCreate.Add(item);
}
else
{
item.ID = itemExistente.ID;
listaUpdate.Add(item);
}
}
// Update em lote
for (int i = 0; i < listaUpdate.Count; i += quantidadePorLote)
{
var retorno = RepositoryService.MetadaUnidadeporSubfamilia.Update(listaUpdate.Skip(i).Take(quantidadePorLote).ToList());
foreach (var item in retorno)
{
listaError.Add(item.Key + " - " + item.Value);
}
}
// Create em lote
for (int i = 0; i < listaCreate.Count; i += quantidadePorLote)
{
var listaEmLote = listaCreate.Skip(i).Take(quantidadePorLote).ToList();
DomainExecuteMultiple retorno = RepositoryService.MetadaUnidadeporSubfamilia.Create(listaEmLote);
if (retorno.IsFaulted)
{
for (int x = 0; x < retorno.List.Length; x++)
{
var item = retorno.List[x];
listaError.Add("Create - " + item.Message);
}
}
}
return(listaError);
}
private Dictionary <Guid, string> AtualizarValoresPotencialSupervisor(MetadaUnidade metaUnidade, int quantidadePorLote)
{
var listaTodos = RepositoryService.PotencialdoSupervisor.ListarValoresPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value);
var listaExistentes = RepositoryService.PotencialdoSupervisor.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value);
var listaError = new Dictionary <Guid, string>();
var listaCreate = new List <PotencialdoSupervisor>();
var listaUpdate = new List <PotencialdoSupervisor>();
foreach (var item in listaTodos)
{
var itemExistente = listaExistentes.Find(x => x.Supervisor.Id == item.Supervisor.Id);
if (itemExistente == null)
{
item.UnidadedeNegocio = metaUnidade.UnidadedeNegocios;
item.Ano = metaUnidade.Ano;
item.Nome = string.Format("{0} - {1}", metaUnidade.UnidadedeNegocios.Name, item.Supervisor.Name);
item.RazaoStatus = (int)Domain.Enum.PotencialdoSupervisor.StatusCode.Ativa;
listaCreate.Add(item);
}
else
{
item.ID = itemExistente.ID;
listaUpdate.Add(item);
}
}
// Update em lote
for (int i = 0; i < listaUpdate.Count; i += quantidadePorLote)
{
var retorno = RepositoryService.PotencialdoSupervisor.Update(listaUpdate.Skip(i).Take(quantidadePorLote).ToList());
foreach (var item in retorno)
{
listaError.Add(item.Key, item.Value);
}
}
// Create em lote
for (int i = 0; i < listaCreate.Count; i += quantidadePorLote)
{
var listaEmLote = listaCreate.Skip(i).Take(quantidadePorLote).ToList();
DomainExecuteMultiple retorno = RepositoryService.PotencialdoSupervisor.Create(listaEmLote);
if (retorno.IsFaulted)
{
for (int x = 0; x < retorno.List.Length; x++)
{
var item = retorno.List[x];
if (item.IsFaulted)
{
listaError.Add(Guid.Empty, item.Message);
}
}
}
}
return(listaError);
}
