public MasterContract UpdateMasterContract(MasterContract contract)
{
MasterContract result = null;
using (IDbConnection connection = new OracleConnection(this.connString))
{
connection.Open();
var parameters = new OracleDynamicParameters();
parameters.Add("p_cd_contrato_master", value: contract.Id, dbType: OracleDbType.Int32, direction: ParameterDirection.Input);
parameters.Add("p_cd_tipo_contrato", value: (contract.DocumentType == null ? "" : contract.DocumentType.Id), dbType: OracleDbType.Char, direction: ParameterDirection.Input);
parameters.Add("p_cd_sales_org", value: (contract.SalesOrganization == null ? "" : contract.SalesOrganization.Id), dbType: OracleDbType.Char, direction: ParameterDirection.Input);
parameters.Add("p_cd_distribution_channel", value: (contract.DistributionChannel == null ? "" : contract.DistributionChannel.Id), dbType: OracleDbType.Char, direction: ParameterDirection.Input);
parameters.Add("p_cd_sales_division", value: contract.SalesDivision.Id, dbType: OracleDbType.Char, direction: ParameterDirection.Input);
parameters.Add("p_cd_sales_group", value: (contract.SalesSupervisor == null ? "" : contract.SalesSupervisor.Code), dbType: OracleDbType.Char, direction: ParameterDirection.Input);
parameters.Add("p_cd_cliente", value: (contract.Customer == null ? "" : contract.Customer.Id), dbType: OracleDbType.Varchar2, direction: ParameterDirection.Input);
parameters.Add("p_dt_inicio", value: contract.StartDate, dbType: OracleDbType.Date, direction: ParameterDirection.Input);
parameters.Add("p_dt_fim", value: contract.EndDate, dbType: OracleDbType.Date, direction: ParameterDirection.Input);
parameters.Add("p_cd_usuario_alteracao", value: (contract.ModifyUser == null ? 0 : contract.ModifyUser.Id), dbType: OracleDbType.Int32, direction: ParameterDirection.Input);
parameters.Add("p_result", dbType: OracleDbType.RefCursor, direction: ParameterDirection.Output);
var multi = connection.QueryMultiple("vnd.gx_contract_master.pu_contrato_master", parameters, commandType: CommandType.StoredProcedure);
var lookup = new Dictionary <int, MasterContract>();
multi.Read(
ObjectsForMapping(),
(objects) => MapDBFieldsToProperties(objects, lookup)
);
if (lookup.Count() > 0)
{
result = lookup.Values.First();
}
}
return(result);
}
public MasterContract InactivateMasterContract(int masterContractId, int userId)
{
MasterContract result = null;
using (IDbConnection connection = new OracleConnection(this.connString))
{
connection.Open();
var parameters = new OracleDynamicParameters();
parameters.Add("p_cd_contrato_master", value: masterContractId, dbType: OracleDbType.Int32, direction: ParameterDirection.Input);
parameters.Add("p_cd_usuario", value: userId, dbType: OracleDbType.Int32, direction: ParameterDirection.Input);
parameters.Add("p_result", dbType: OracleDbType.RefCursor, direction: ParameterDirection.Output);
var multi = connection.QueryMultiple("vnd.gx_contract_master.pu_inactivate_contrato_master", param: parameters, commandType: CommandType.StoredProcedure);
var lookup = new Dictionary <int, MasterContract>();
multi.Read(
ObjectsForMapping(),
(objects) => MapDBFieldsToProperties(objects, lookup)
);
if (lookup.Count() > 0)
{
result = lookup.Values.First();
}
}
return(result);
}
public MasterContract InactivateMasterContract(int masterContractId, int userId)
{
ContractDAO contractDao = new ContractDAO(connectionString);
MasterContract result = contractDao.InactivateMasterContract(masterContractId, userId);
return(result);
}
public MasterContract GetMasterContract(int masterContractId)
{
ContractDAO contractDAO = new ContractDAO(connectionString);
MasterContract masterContract = contractDAO.GetMasterContract(masterContractId);
return(masterContract);
}
private void SavePeriods(MasterContract masterContract)
{
PeriodDAO periodDAO = new PeriodDAO(connectionString);
Period result;
// Remove existing periods in database that didn't come in the post.
List <Period> periodsFromDB = (List <Period>)periodDAO.ListByContract(masterContract.Id);
foreach (Period periodFromDB in periodsFromDB)
{
var x = from mi in masterContract.MasterContractItems
from p in mi.Periods
where p.UID == periodFromDB.UID
select p;
if (x.Count() == 0)
{
periodFromDB.ModifyUser = masterContract.ModifyUser;
periodDAO.Delete(periodFromDB);
}
}
// Save the periods that came in the post.
foreach (MasterContractItem contractMasterItem in masterContract.MasterContractItems)
{
foreach (Period period in contractMasterItem.Periods)
{
result = period;
if (period.Id == 0 && period.Quantity > 0)
{
period.CreationUser = masterContract.CreationUser;
result = periodDAO.InsertPeriod(masterContract.Id, contractMasterItem.Id, period);
}
else if (period.Id != 0 && period.Quantity > 0)
{
period.ModifyUser = masterContract.ModifyUser;
result = periodDAO.UpdatePeriod(period);
}
// We want to keep the period, assuming that the start and end dates have not changed.
//else if (period.Id != 0 && period.Quantity == 0)
//{
// period.ModifyUser = masterContract.ModifyUser;
// periodDAO.Delete(period);
//}
if (result != null)
{
period.Id = result.Id;
period.Date = result.Date;
}
}
}
}
public Result Save([FromBody] MasterContract masterContract)
{
Result result = new Result(success: true);
ValidationResult validationResult = masterContract.Validate();
if (!validationResult.IsValid)
{
result.Success = false;
result.Messages = validationResult.Messages;
}
else
{
ContractService contractService = new ContractService();
MasterContract savedMasterContract = contractService.SaveMasterContract(masterContract);
result.Payload = savedMasterContract;
}
return(result);
}
public List <NormalContract> CheckNormalContractsFromMasterContract(int masterContractId)
{
List <NormalContract> contractsNotFound = new List <NormalContract>();
ContractDAO contractDAO = new ContractDAO(connectionString);
MasterContract masterContract = contractDAO.GetMasterContract(masterContractId);
this.MakeContractsFromMasterItems(masterContract);
List <NormalContract> normalContractsThatShouldExist = this.MakeContractsFromMasterItems(masterContract);
foreach (NormalContract normalContractThatShouldExist in normalContractsThatShouldExist)
{
IEnumerable <NormalContract> contractsFound = from existingNormalContract in masterContract.NormalContracts
where existingNormalContract.StartDate == normalContractThatShouldExist.StartDate && existingNormalContract.EndDate == normalContractThatShouldExist.EndDate
select existingNormalContract;
if (contractsFound.Count() == 0)
{
contractsNotFound.Add(normalContractThatShouldExist);
continue;
}
else
{
foreach (NormalContractItem itemThatShouldExist in normalContractThatShouldExist.NormalContractItems)
{
IEnumerable <NormalContractItem> itemsFound = from existingNormalContract in contractsFound
from existingItem in existingNormalContract.NormalContractItems
where existingItem.Material.Id == itemThatShouldExist.Material.Id && existingItem.Quantity == itemThatShouldExist.Quantity
select existingItem;
if (itemsFound.Count() == 0)
{
contractsNotFound.Add(normalContractThatShouldExist);
continue;
}
}
}
}
return(contractsNotFound);
}
private void SaveContractMasterItems(MasterContract masterContract)
{
ContractItemDAO contractItemDAO = new ContractItemDAO(connectionString);
MasterContractItem result;
foreach (MasterContractItem contractMasterItem in masterContract.MasterContractItems)
{
if (contractMasterItem.Id == 0)
{
contractMasterItem.CreationUser = masterContract.CreationUser;
result = contractItemDAO.InsertContractMasterItem(masterContract.Id, contractMasterItem);
}
else
{
contractMasterItem.ModifyUser = masterContract.ModifyUser;
contractMasterItem.ContractId = masterContract.Id;
result = contractItemDAO.UpdateContractMasterItem(contractMasterItem);
}
if (result != null)
{
contractMasterItem.Id = result.Id;
}
}
}
public MasterContract SaveMasterContract(MasterContract masterContract)
{
ContractDAO contractDao = new ContractDAO(connectionString);
MasterContract result;
if (masterContract.Id == 0)
{
result = contractDao.InsertMasterContract(masterContract);
}
else
{
result = contractDao.UpdateMasterContract(masterContract);
}
if (result != null)
{
masterContract.Id = result.Id;
masterContract.Active = result.Active;
SaveContractMasterItems(masterContract);
SavePeriods(masterContract);
}
return(masterContract);
}
public Result SetMasterContractSentToSAP(MasterContract masterContract)
{
Result result = new Result(success: true);
try
{
using (IDbConnection connection = new OracleConnection(this.connString))
{
connection.Open();
var parameters = new OracleDynamicParameters();
parameters.Add("p_cd_contrato_master", value: masterContract.Id, dbType: OracleDbType.Int32, direction: ParameterDirection.Input);
parameters.Add("p_cd_usuario", value: (masterContract.GeneratorUser == null ? 0 : masterContract.GeneratorUser.Id), dbType: OracleDbType.Int32, direction: ParameterDirection.Input);
connection.Execute("vnd.gx_contract_master.pu_set_master_sent_to_sap", param: parameters, commandType: CommandType.StoredProcedure);
}
}
catch (Exception ex)
{
result.Success = false;
result.Messages.Add(ex.Message);
}
return(result);
}
public List <NormalContract> MakeContractsFromMasterItems(MasterContract masterContract)
{
// For each period of every contract master item,
// create a new contract and add it to a list.
//
// Example:
//
// master item # | Period 1 | Period 2 | Period 3 |
// -----------------|----------|----------|----------|
// 10 | 90 | 150 | 230 |
// 20 | 120 | 70 | 0 |
//
// Would create 5 contracts with one item each.
List <NormalContract> contractsFromPeriods = new List <NormalContract>();
foreach (MasterContractItem masterItem in masterContract.MasterContractItems)
{
var periodsWithQuantity = masterItem.Periods.Where(p => p.Quantity > 0);
foreach (Period period in periodsWithQuantity)
{
NormalContract contract = new NormalContract()
{
StartDate = period.Date,
DocumentType = masterContract.DocumentType,
DistributionChannel = masterContract.DistributionChannel,
SalesOrganization = masterContract.SalesOrganization,
SalesDivision = masterContract.SalesDivision,
SalesSupervisor = masterContract.SalesSupervisor,
Customer = masterContract.Customer,
MasterContractId = masterContract.Id
};
contract.NormalContractItems.Add(new NormalContractItem
{
Material = masterItem.Material,
Incoterms = masterItem.Incoterms,
Region = masterItem.Region,
Quantity = period.Quantity
});
contractsFromPeriods.Add(contract);
}
}
// Group the contracts by Start Date.
var contractsGroupped = contractsFromPeriods
.OrderBy(p => p.StartDate)
.GroupBy(p => p.StartDate)
.Select(grp => grp.ToList())
.ToList();
// For every group of contracts, create a new Contract with the items merged.
//
// Example:
//
// master item # | Period 1 | Period 2 | Period 3 |
// -----------------|----------|----------|----------|
// 10 | 90 | 150 | 230 |
// 20 | 120 | 70 | 0 |
//
// Would create 3 contracts:
// - Contract 1: Two items => 90t and 120t.
// - Contract 2: Two items => 150t and 70t.
// - Contract 3: One item => 230t.
var contracts = from g in contractsGroupped
select new NormalContract
{
StartDate = g.First().StartDate,
EndDate = g.First().StartDate.Value.LastDayOfMonth(),
Customer = g.First().Customer,
DistributionChannel = g.First().DistributionChannel,
DocumentType = g.First().DocumentType,
SalesOrganization = g.First().SalesOrganization,
SalesDivision = g.First().SalesDivision,
SalesSupervisor = g.First().SalesSupervisor,
MasterContractId = g.First().MasterContractId,
NormalContractItems = (
from c in g
from i in c.NormalContractItems
select i
).ToList()
};
List <NormalContract> finalListOfContracts = contracts.OrderBy(c => c.StartDate).ToList();
finalListOfContracts.First().StartDate = masterContract.StartDate;
finalListOfContracts.Last().EndDate = masterContract.EndDate;
return(finalListOfContracts);
}
public Result SendMasterContractToSAP(int masterContractId, int userId)
{
Result finalResult = new Result(success: false);
ContractService contractService = new ContractService();
ContractDAO contractDAO = new ContractDAO(connectionString);
try
{
MasterContract masterContract = contractDAO.GetMasterContract(masterContractId);
List <NormalContract> normalContracts = contractService.MakeContractsFromMasterItems(masterContract);
if (normalContracts.Count > 0)
{
contractDAO.SetQuantityOfContractsInMasterContract(masterContractId, normalContracts.Count);
List <SendToSAPResult> allResultsFromSendToSAP = new List <SendToSAPResult>();
foreach (NormalContract normalContract in normalContracts)
{
normalContract.CreationUser = new User {
Id = userId
};
GenerateAndSaveNormalContractAndItems(normalContract);
List <Result> listOfResultsForThisContract = SendNormalContractToSAP(normalContract);
var resultsWithFailures = from contractResult in listOfResultsForThisContract
where contractResult.Success == false
select contractResult;
allResultsFromSendToSAP.Add(new SendToSAPResult
{
NormalContract = normalContract,
Payload = listOfResultsForThisContract,
Success = (resultsWithFailures.Count() == 0)
});
}
var failedResults = from r in allResultsFromSendToSAP
from r1 in r.Payload as List <Result>
where r1.Success == false
select r1;
if (failedResults.Count() == 0)
{
finalResult.Success = true;
}
// Update the Master Contract as generated and sent to SAP.
masterContract.GeneratorUser = new User {
Id = userId
};
masterContract.SenderToSAPUser = new User {
Id = userId
};
contractDAO.SetMasterContractSentToSAP(masterContract);
finalResult.Payload = allResultsFromSendToSAP;
}
else
{
finalResult.Messages.Add("Contratos não gerados.");
}
}
catch (Exception ex)
{
finalResult.Messages.Add(ex.Message);
}
return(finalResult);
}
