// garantir que o tipo de quantidade da descrição física existe aquando da sua gravação na BD
private void TipoAcondicionamentoIsBeingUsedByOthers(GISA.Model.PersistencyHelper.PreConcArguments args)
{
GISA.Model.PersistencyHelper.ManageDescFisicasPreConcArguments mcfPca = null;
mcfPca = (GISA.Model.PersistencyHelper.ManageDescFisicasPreConcArguments)args;
GISADataset.FRDBaseRow frd = (GISADataset.FRDBaseRow)(GisaDataSetHelper.GetInstance().FRDBase.Select("ID=" + mcfPca.frdID.ToString())[0]);
ArrayList quantList = mcfPca.quant;
int nTQuant = 0;
GISADataset.TipoAcondicionamentoRow row = null;
try
{
foreach (long quant in quantList)
{
row = (GISADataset.TipoAcondicionamentoRow)(GisaDataSetHelper.GetInstance().TipoAcondicionamento.Select("ID=" + quant.ToString(), "", DataViewRowState.Deleted)[0]);
nTQuant = FRDRule.Current.CountUFDimensoesAcumuladas(quant, mcfPca.tran);
System.Data.DataSet tempgisaBackup1 = mcfPca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup1, row);
mcfPca.gisaBackup = tempgisaBackup1;
if (nTQuant > 0)
{
row.RejectChanges();
mcfPca.aResult = PersistencyHelper.ManageDescFisicasPreConcArguments.ActionResult.quantidadeUsedByOthers;
}
}
}
catch (Exception ex)
{
Trace.WriteLine(ex);
throw ex;
}
}
public static void ValidateMovimentoDelete(PersistencyHelper.PreConcArguments args)
{
var vmdiPsa = args as PersistencyHelper.ValidateMovimentoDeleteItemPreConcArguments;
var dmRow = GisaDataSetHelper.GetInstance().DocumentosMovimentados.Cast <GISADataset.DocumentosMovimentadosRow>()
.SingleOrDefault(r => r.RowState == DataRowState.Deleted && (long)r["IDNivel", DataRowVersion.Original] == vmdiPsa.IDNivel && (long)r["IDMovimento", DataRowVersion.Original] == vmdiPsa.IDMovimento);
// este caso acontece quando a linha está detached (o documento foi adicionado, e antes de ser gravado, foi removido da requisição/devolução)
if (dmRow == null)
{
return;
}
// não é permitido eliminar a associação de documentos a devoluções com requisições posteriores mas sem devolução
// não é permitido eliminar a associação de documentos a requisições com devolução posterior
vmdiPsa.continueSave = !DBAbstractDataLayer.DataAccessRules.MovimentoRule.Current.temMovimentosPosteriores(vmdiPsa.IDNivel, vmdiPsa.IDMovimento, vmdiPsa.CatCode, args.tran);
if (vmdiPsa.continueSave)
{
return;
}
System.Data.DataSet tempgisaBackup2 = vmdiPsa.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup2, dmRow);
vmdiPsa.gisaBackup = tempgisaBackup2;
dmRow.RejectChanges();
}
public static void verificaCodigosRepetidos(PersistencyHelper.PreConcArguments args)
{
var pcArgs = (PersistencyHelper.EnsureUniqueCodigoNivelPreConcArguments)args;
var rhRow = GisaDataSetHelper.GetInstance().RelacaoHierarquica.Cast <GISADataset.RelacaoHierarquicaRow>().SingleOrDefault(r => r.RowState != DataRowState.Deleted && r.ID == pcArgs.rhRowID && r.IDUpper == pcArgs.rhRowIDUpper);
if (rhRow != null)
{
var codigo = rhRow.NivelRowByNivelRelacaoHierarquica.Codigo;
var ID = DBAbstractDataLayer.DataAccessRules.NivelRule.Current.GetIDCodigoRepetido(codigo, rhRow.ID, pcArgs.tran, pcArgs.testOnlyWithinNivel, rhRow.NivelRowByNivelRelacaoHierarquicaUpper.ID);
if (ID > long.MinValue)
{
// erro
pcArgs.message = string.Format(
"Não foi possível completar a operação uma vez que" + Environment.NewLine +
"por debaixo da entidade produtora selecionada" + Environment.NewLine +
"o código parcial '{0}' já é utilizado pela unidade " + Environment.NewLine +
"informacional com o identificador {1}.", codigo, rhRow.ID);
var tempgisaBackup3 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup3, rhRow);
pcArgs.gisaBackup = tempgisaBackup3;
rhRow.RejectChanges();
}
else
{
pcArgs.successful = true;
}
}
}
public static void DeleteInDataSet(DataRow DeletableRow, bool onlyRemove, DataSet gBackup)
{
// Parte-se do pressuposto que o nivel a apagar é folha
ArrayList open = new ArrayList();
ArrayList closed = new ArrayList();
open.Add(DeletableRow);
// open -> rows por expandir
// closed -> rows já expandidas
while (open.Count > 0)
{
DataRow current = (DataRow)(open[0]);
if (! (closed.Contains(current)))
{
foreach (DataRelation rel in current.Table.DataSet.Relations)
{
if (rel.ParentTable == current.Table)
{
open.AddRange(current.GetChildRows(rel, DataRowVersion.Default));
}
}
closed.Add(current);
open.Remove(current);
}
}
// Remover do dataset todas as linhas encontradas começando pelo fim
// de forma a manter a integridade referencial
try
{
for (int i = closed.Count - 1; i >= 0; i--)
{
DataRow current = (DataRow)(closed[i]);
Trace.WriteLine(string.Format("{0}.{1} is Delete'ing DataRow from DataTable {2}", new System.Diagnostics.StackFrame().GetMethod().DeclaringType.FullName, new System.Diagnostics.StackFrame().GetMethod().Name, current.Table.TableName));
if (onlyRemove)
{
current.Table.Rows.Remove(current);
}
else
{
if (gBackup != null)
{
PersistencyHelper.BackupRow(ref gBackup, current);
}
current.Delete();
}
}
}
catch (Exception e)
{
Trace.WriteLine(e.ToString());
}
}
private void editTrusteeIfUsernameDoesntExist(PersistencyHelper.PreConcArguments args)
{
PersistencyHelper.EditTrusteePreConcArguments etpca = null;
etpca = (PersistencyHelper.EditTrusteePreConcArguments)args;
etpca.successful = false;
DataSet gisaBackup = etpca.gisaBackup;
if (DBAbstractDataLayer.DataAccessRules.TrusteeRule.Current.isValidNewTrustee(etpca.username, etpca.tran))
{
PersistencyHelper.BackupRow(ref gisaBackup, etpca.truRow);
etpca.truRow.Name = etpca.username;
etpca.successful = true;
}
}
//metodo responsavel por eliminar todos os termos de um CA que não estejam a ser utilizados por outros
public static void deleteCAXTermos(PersistencyHelper.PreConcArguments args)
{
long caRowID = ((PersistencyHelper.DeleteCAXPreConcArguments)args).caRowID;
string catCode = ((PersistencyHelper.DeleteCAXPreConcArguments)args).catCode;
DataSet gisaBackup = ((PersistencyHelper.DeleteCAXPreConcArguments)args).gisaBackup;
foreach (GISADataset.DicionarioRow drow in ((PersistencyHelper.DeleteCAXPreConcArguments)args).termos)
{
//Nota: é necessário verificar se o estado de drow é deleted pelo facto de ser possivel, numa situação de concorência
//entre clientes oracle (só neste tipo de clientes é que esta situação se verificou) que obriga a re-executar a transacção;
//apesar de existir um método que repõe os valores originais, este só é executado após todos os delegates PreConc o que
//neste caso concreto vai apagar as datarows da tabela Dicionario
if (! (DiplomaModeloRule.Current.isTermoUsedByOthers(caRowID, catCode, drow.Termo, true, args.tran)))
{
PersistencyHelper.BackupRow(ref gisaBackup, drow);
drow.Delete();
}
}
}
public static void EnsureNivelUpperExists(PersistencyHelper.PreConcArguments args)
{
PersistencyHelper.VerifyIfRHNivelUpperExistsPreConcArguments pcArgs = null;
pcArgs = (PersistencyHelper.VerifyIfRHNivelUpperExistsPreConcArguments)args;
GISADataset.NivelRow nRow = (GISADataset.NivelRow)(GisaDataSetHelper.GetInstance().Nivel.Select("ID=" + pcArgs.nRowID.ToString())[0]);
long rhRowIDUpper = nRow.GetRelacaoHierarquicaRowsByNivelRelacaoHierarquica()[0].IDUpper;
if (rhRowIDUpper < 0)
{
pcArgs.RHNivelUpperExists = true;
}
else
{
// antes de obter o código verificar se adição de um novo nível ainda é possível (por razões de concorrência)
pcArgs.RHNivelUpperExists = NivelRule.Current.isNivelDeleted(rhRowIDUpper, args.tran);
}
if (!pcArgs.RHNivelUpperExists)
{
GISADataset.RelacaoHierarquicaRow rhRow = (GISADataset.RelacaoHierarquicaRow)(GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", pcArgs.rhRowID, pcArgs.rhRowIDUpper))[0]);
GISADataset.NivelDesignadoRow ndRow = (GISADataset.NivelDesignadoRow)(GisaDataSetHelper.GetInstance().NivelDesignado.Select("ID=" + pcArgs.ndRowID.ToString())[0]);
GISADataset.FRDBaseRow frdBaseRow = (GISADataset.FRDBaseRow)(GisaDataSetHelper.GetInstance().FRDBase.Select("ID=" + pcArgs.frdBaseID.ToString())[0]);
System.Data.DataSet tempgisaBackup1 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup1, rhRow);
pcArgs.gisaBackup = tempgisaBackup1;
rhRow.RejectChanges();
System.Data.DataSet tempgisaBackup2 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup2, ndRow);
pcArgs.gisaBackup = tempgisaBackup2;
ndRow.RejectChanges();
System.Data.DataSet tempgisaBackup3 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup3, nRow);
pcArgs.gisaBackup = tempgisaBackup3;
nRow.RejectChanges();
System.Data.DataSet tempgisaBackup4 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup4, frdBaseRow);
pcArgs.gisaBackup = tempgisaBackup4;
frdBaseRow.RejectChanges();
pcArgs.message = "Não foi possível criar a unidade informacional uma" + Environment.NewLine + "vez que a unidade superior foi apagada por outro utilizador.";
}
}
public static void DeleteMovimento(PersistencyHelper.PreConcArguments args)
{
var dmPca = args as PersistencyHelper.DeleteMovimentoPreConcArguments;
var dmRow = GisaDataSetHelper.GetInstance().Movimento.Cast <GISADataset.MovimentoRow>()
.Single(r => r.RowState == DataRowState.Deleted && (long)r["ID", DataRowVersion.Original] == dmPca.IDMovimento);
// Não é permitido eliminar requisições de documentos devolvidos posteriormente nem eliminar devoluções
// com requisições posteriores (sem devolução) dos mesmos documentos
dmPca.continueSave = !DBAbstractDataLayer.DataAccessRules.MovimentoRule.Current.CanDeleteMovimento(dmPca.IDMovimento, dmPca.CatCode, args.tran);
if (dmPca.continueSave)
{
return;
}
System.Data.DataSet tempgisaBackup2 = dmPca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup2, dmRow);
dmPca.gisaBackup = tempgisaBackup2;
dmRow.RejectChanges();
}
private void AddTrusteeIfUsernameDoesntExist(PersistencyHelper.PreConcArguments args)
{
PersistencyHelper.CreateTrusteePreConcArguments cetpca = null;
cetpca = (PersistencyHelper.CreateTrusteePreConcArguments)args;
GISADataset.TrusteeRow truRow = (GISADataset.TrusteeRow)(GisaDataSetHelper.GetInstance().Trustee.Select("ID=" + cetpca.truRowID.ToString())[0]);
GISADataset.TrusteeUserRow usrRow = (GISADataset.TrusteeUserRow)(GisaDataSetHelper.GetInstance().TrusteeUser.Select("ID=" + cetpca.usrRowID.ToString())[0]);
if (! (DBAbstractDataLayer.DataAccessRules.TrusteeRule.Current.isValidNewTrustee(truRow.Name, cetpca.tran)))
{
System.Data.DataSet tempgisaBackup1 = cetpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup1, usrRow);
cetpca.gisaBackup = tempgisaBackup1;
System.Data.DataSet tempgisaBackup2 = cetpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup2, truRow);
cetpca.gisaBackup = tempgisaBackup2;
usrRow.RejectChanges();
truRow.RejectChanges();
cetpca.successful = false;
}
else
cetpca.successful = true;
}
public static void HandleUF(PersistencyHelper.PreConcArguments args)
{
PersistencyHelper.AddEditUFPreConcArguments aeufpca = null;
PersistencyHelper.IsCodigoUFBeingUsedPreSaveArguments psa = null;
aeufpca = (PersistencyHelper.AddEditUFPreConcArguments)args;
psa = (PersistencyHelper.IsCodigoUFBeingUsedPreSaveArguments)aeufpca.psa;
psa.cancelSetNewCodigo = false;
aeufpca.message = string.Empty;
GISADataset.RelacaoHierarquicaRow rhufRow = null;
if (GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", aeufpca.rhufRowID, aeufpca.rhufRowIDUpper)).Length > 0)
{
rhufRow = (GISADataset.RelacaoHierarquicaRow)(GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", aeufpca.rhufRowID, aeufpca.rhufRowIDUpper))[0]);
}
else if (GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", aeufpca.rhufRowID, aeufpca.rhufRowIDUpper), "", DataViewRowState.Deleted).Length > 0)
{
rhufRow = (GISADataset.RelacaoHierarquicaRow)(GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", aeufpca.rhufRowID, aeufpca.rhufRowIDUpper), "", DataViewRowState.Deleted)[0]);
}
GISADataset.NivelDesignadoRow ndufRow = (GISADataset.NivelDesignadoRow)(GisaDataSetHelper.GetInstance().NivelDesignado.Select("ID=" + aeufpca.ndufRowID.ToString())[0]);
GISADataset.NivelRow nivelUFRow = (GISADataset.NivelRow)(GisaDataSetHelper.GetInstance().Nivel.Select("ID=" + aeufpca.nivelUFRowID.ToString())[0]);
if (aeufpca.Operation == PersistencyHelper.AddEditUFPreConcArguments.Operations.Create || aeufpca.Operation == PersistencyHelper.AddEditUFPreConcArguments.Operations.CreateLike)
{
GISADataset.NivelUnidadeFisicaRow nufufRow = (GISADataset.NivelUnidadeFisicaRow)(GisaDataSetHelper.GetInstance().NivelUnidadeFisica.Select("ID=" + aeufpca.nufufRowID.ToString())[0]);
// validar criação de UF
if (DBAbstractDataLayer.DataAccessRules.UFRule.Current.isNivelRowDeleted(rhufRow.NivelRowByNivelRelacaoHierarquicaUpper.ID, aeufpca.tran))
{
var tempgisaBackup = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup, nufufRow);
aeufpca.gisaBackup = tempgisaBackup;
nufufRow.RejectChanges();
PersistencyHelper.BackupRow(ref tempgisaBackup, rhufRow);
aeufpca.gisaBackup = tempgisaBackup;
rhufRow.RejectChanges();
PersistencyHelper.BackupRow(ref tempgisaBackup, ndufRow);
aeufpca.gisaBackup = tempgisaBackup;
ndufRow.RejectChanges();
PersistencyHelper.BackupRow(ref tempgisaBackup, nivelUFRow);
aeufpca.gisaBackup = tempgisaBackup;
nivelUFRow.RejectChanges();
List <DataRow> lstRows = new List <DataRow>();
// recolher rows para fazer backup caso a operação seja "CREATE LIKE"
if (aeufpca.Operation == PersistencyHelper.AddEditUFPreConcArguments.Operations.CreateLike)
{
lstRows.AddRange(GisaDataSetHelper.GetInstance().SFRDDatasProducao.Select("IDFRDBase=" + aeufpca.frdufRowID.ToString()));
lstRows.AddRange(GisaDataSetHelper.GetInstance().SFRDUFCota.Select("IDFRDBase=" + aeufpca.frdufRowID.ToString()));
lstRows.AddRange(GisaDataSetHelper.GetInstance().SFRDConteudoEEstrutura.Select("IDFRDBase=" + aeufpca.frdufRowID.ToString()));
lstRows.AddRange(GisaDataSetHelper.GetInstance().SFRDUFDescricaoFisica.Select("IDFRDBase=" + aeufpca.frdufRowID.ToString()));
foreach (long uaAssociadaID in aeufpca.uaAssociadas)
{
lstRows.AddRange(GisaDataSetHelper.GetInstance().SFRDUnidadeFisica.Select(string.Format("IDFRDBase={0} AND IDNivel={1}", uaAssociadaID, aeufpca.nivelUFRowID)));
}
}
lstRows.AddRange(GisaDataSetHelper.GetInstance().FRDBase.Select("ID=" + aeufpca.frdufRowID.ToString()));
PersistencyHelper.BackupRows(ref tempgisaBackup, lstRows);
aeufpca.gisaBackup = tempgisaBackup;
aeufpca.OperationError = PersistencyHelper.AddEditUFPreConcArguments.OperationErrors.NewUF;
aeufpca.message = "A entidade produtora que pretende associar à unidade física foi eliminada por outro utilizador. Esta operação não poderá, por isso, ser concluída.";
psa.cancelSetNewCodigo = true;
aeufpca.continueSave = false;
}
}
else
{
// validar edição de UF
bool isUFDeleted = DBAbstractDataLayer.DataAccessRules.UFRule.Current.isNivelRowDeleted(nivelUFRow.ID, aeufpca.tran);
// verificar se a UF a editar não foi apagada por outro utilizador
if (isUFDeleted)
{
System.Data.DataSet tempgisaBackup6 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup6, ndufRow);
aeufpca.gisaBackup = tempgisaBackup6;
ndufRow.RejectChanges();
System.Data.DataSet tempgisaBackup7 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup7, nivelUFRow);
aeufpca.gisaBackup = tempgisaBackup7;
nivelUFRow.RejectChanges();
aeufpca.OperationError = PersistencyHelper.AddEditUFPreConcArguments.OperationErrors.EditEDAndDesignacao;
aeufpca.message = "A unidade física em edição foi eliminada por outro utilizador. " + Environment.NewLine + "Esta operação não poderá, por isso, ser concluída.";
psa.cancelSetNewCodigo = true;
aeufpca.continueSave = false;
return;
}
// Verificar se se pretende alterar a entidade detentora associada
bool isRelacaoHierarquicaDeleted = false;
if (rhufRow.RowState == DataRowState.Deleted)
{
isRelacaoHierarquicaDeleted = DBAbstractDataLayer.DataAccessRules.UFRule.Current.isRelacaoHierarquicaDeleted(aeufpca.rhufRowID, aeufpca.rhufRowIDUpper, aeufpca.tran);
}
else
{
// a operação pretendida é editar a designação da UF e por esse motivo não é necessário
// atribuir um novo código (a operação não é create e a entidade detentora não foi alterada)
psa.cancelSetNewCodigo = true;
aeufpca.continueSave = false;
}
GISADataset.RelacaoHierarquicaRow[] newRhufRow = (GISADataset.RelacaoHierarquicaRow[])(GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", aeufpca.newRhufRowID, aeufpca.newRhufRowIDUpper)));
// Verificar se outro utilizador também alterou (concorrentemente) a entidade detentora associada
if (isRelacaoHierarquicaDeleted)
{
System.Data.DataSet tempgisaBackup8 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup8, newRhufRow[0]);
aeufpca.gisaBackup = tempgisaBackup8;
newRhufRow[0].RejectChanges();
System.Data.DataSet tempgisaBackup9 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup9, rhufRow);
aeufpca.gisaBackup = tempgisaBackup9;
rhufRow.RejectChanges();
System.Data.DataSet tempgisaBackup10 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup10, nivelUFRow);
aeufpca.gisaBackup = tempgisaBackup10;
nivelUFRow.RejectChanges();
aeufpca.OperationError = PersistencyHelper.AddEditUFPreConcArguments.OperationErrors.EditOriginalEd;
aeufpca.message = "A entidade detentora da unidade física em edição foi alterada por outro utilizador." + Environment.NewLine + "Esta operação não poderá, por isso, ser concluída.";
psa.cancelSetNewCodigo = true;
aeufpca.continueSave = false;
}
else if (newRhufRow.Length > 0) // se tivermos alterado a entidade detentora da uf
{
// verificar se a ED a associar à UF não foi apagada por outro utilizador
if (DBAbstractDataLayer.DataAccessRules.UFRule.Current.isNivelRowDeleted(newRhufRow[0].NivelRowByNivelRelacaoHierarquicaUpper.ID, aeufpca.tran))
{
System.Data.DataSet tempgisaBackup11 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup11, newRhufRow[0]);
aeufpca.gisaBackup = tempgisaBackup11;
newRhufRow[0].RejectChanges();
System.Data.DataSet tempgisaBackup12 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup12, rhufRow);
aeufpca.gisaBackup = tempgisaBackup12;
rhufRow.RejectChanges();
System.Data.DataSet tempgisaBackup13 = aeufpca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup13, nivelUFRow);
aeufpca.gisaBackup = tempgisaBackup13;
nivelUFRow.RejectChanges();
if (!isUFDeleted)
{
// UF existe mas a ED que se pretende adicionar não
aeufpca.OperationError = PersistencyHelper.AddEditUFPreConcArguments.OperationErrors.EditNewEd;
aeufpca.message = "A entidade produtora que pretende associar à unidade física foi eliminada por outro utilizador. Esta operação não poderá, por isso, ser concluída.";
}
psa.cancelSetNewCodigo = true;
aeufpca.continueSave = false;
}
//else if (!isUFDeleted)
//{
// // Tanto a UF como a ED existem;
// NivelRule.Current.DeleteSFRDUnidadeFisica(nivelUFRow.ID, aeufpca.tran);
// foreach (GISADataset.SFRDUnidadeFisicaRow relacaoRow in nivelUFRow.GetSFRDUnidadeFisicaRows())
// {
// System.Data.DataSet tempgisaBackup14 = aeufpca.gisaBackup;
// PersistencyHelper.BackupRow(ref tempgisaBackup14, relacaoRow);
// aeufpca.gisaBackup = tempgisaBackup14;
// relacaoRow.Delete();
// }
//}
}
}
}
// utilizado no contexto das eliminações
public static void verifyIfCanDeleteRH(PersistencyHelper.PreConcArguments args)
{
PersistencyHelper.canDeleteRHRowPreConcArguments cdrhPca = null;
cdrhPca = (PersistencyHelper.canDeleteRHRowPreConcArguments)args;
GISADataset.NivelRow nRow = (GISADataset.NivelRow)(GisaDataSetHelper.GetInstance().Nivel.Select("ID=" + cdrhPca.nRowID.ToString())[0]);
GISADataset.NivelRow nUpperRow = null;
if (GisaDataSetHelper.GetInstance().Nivel.Select("ID=" + cdrhPca.nUpperRowID.ToString()).Length > 0)
{
nUpperRow = (GISADataset.NivelRow)(GisaDataSetHelper.GetInstance().Nivel.Select("ID=" + cdrhPca.nUpperRowID.ToString())[0]);
}
GISADataset.RelacaoHierarquicaRow rhRow = null;
if (GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", cdrhPca.rhRowID, cdrhPca.rhRowIDUpper)).Length > 0)
{
rhRow = (GISADataset.RelacaoHierarquicaRow)(GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", cdrhPca.rhRowID, cdrhPca.rhRowIDUpper))[0]);
}
// Permitir apenas a eliminação de folhas e de níveis cuja
// a funcionalidade eliminação não elimina o nível propriamente
// dito mas sim a sua relação com o nível superior
int parentCount = 0;
int directChildCount = 0;
bool moreThenOneParent = false;
bool notExistsDirectChild = false;
parentCount = DBAbstractDataLayer.DataAccessRules.NivelRule.Current.getParentCount(cdrhPca.nRowID.ToString(), cdrhPca.tran);
directChildCount = DBAbstractDataLayer.DataAccessRules.NivelRule.Current.getDirectChildCount(cdrhPca.nRowID.ToString(), string.Empty, cdrhPca.tran);
moreThenOneParent = parentCount > 1;
notExistsDirectChild = directChildCount == 0;
Trace.WriteLine("parentCount: " + parentCount.ToString());
Trace.WriteLine("directChildCount: " + directChildCount.ToString());
if (!(!(TipoNivel.isNivelOrganico(nRow) && TipoNivel.isNivelOrganico(nUpperRow)) && (TipoNivel.isNivelOrganico(nRow) || (TipoNivel.isNivelOrganico(nUpperRow) && moreThenOneParent) || (notExistsDirectChild))))
{
string filter = string.Format("rh.IDTipoNivelRelacionado != {0:d}", TipoNivelRelacionado.UF);
parentCount = DBAbstractDataLayer.DataAccessRules.NivelRule.Current.getParentCount(cdrhPca.nRowID.ToString(), cdrhPca.tran);
directChildCount = DBAbstractDataLayer.DataAccessRules.NivelRule.Current.getDirectChildCount(cdrhPca.nRowID.ToString(), filter, cdrhPca.tran);
moreThenOneParent = parentCount > 1;
notExistsDirectChild = directChildCount == 0;
Trace.WriteLine("parentCount: " + parentCount.ToString());
Trace.WriteLine("directChildCount: " + directChildCount.ToString());
cdrhPca.deleteSuccessful = false;
cdrhPca.continueSave = false;
if (!(!(TipoNivel.isNivelOrganico(nRow) && TipoNivel.isNivelOrganico(nUpperRow)) && (TipoNivel.isNivelOrganico(nRow) || (TipoNivel.isNivelOrganico(nUpperRow) && moreThenOneParent) || (notExistsDirectChild))))
{
cdrhPca.message = "Só é possível eliminar os níveis que não tenham outros níveis directamente associados";
}
else
{
cdrhPca.message = "Existem unidades físicas associadas a este nível não podendo por isso ser eliminado.";
}
}
else
{
//ToDo: simplificar este IF: o facto de rhrow ser nothing indica o caso onde é necessario executar o
// o método DeleteInDataSet
if (rhRow != null)
{
System.Data.DataSet tempgisaBackup1 = cdrhPca.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup1, rhRow);
cdrhPca.gisaBackup = tempgisaBackup1;
rhRow.Delete();
}
else
{
Nivel.DeleteInDataSet(nRow, false, cdrhPca.gisaBackup); // é possível que esta linha não seja já precisa uma vez que o cleandeleteddata seguinte irá limpar do DS de trabalho as linhas que já não existam
}
}
}
public static void ensureUniqueCodigo(PersistencyHelper.PreConcArguments args)
{
PersistencyHelper.EnsureUniqueCodigoNivelPreConcArguments pcArgs = null;
pcArgs = (PersistencyHelper.EnsureUniqueCodigoNivelPreConcArguments)args;
GISADataset.NivelRow nRow = (GISADataset.NivelRow)(GisaDataSetHelper.GetInstance().Nivel.Select("ID=" + pcArgs.nRowID.ToString())[0]);
GISADataset.NivelDesignadoRow ndRow = (GISADataset.NivelDesignadoRow)(GisaDataSetHelper.GetInstance().NivelDesignado.Select("ID=" + pcArgs.ndRowID.ToString())[0]);
GISADataset.RelacaoHierarquicaRow rhRow = null;
if (GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", pcArgs.rhRowID, pcArgs.rhRowIDUpper)).Length > 0)
{
rhRow = (GISADataset.RelacaoHierarquicaRow)(GisaDataSetHelper.GetInstance().RelacaoHierarquica.Select(string.Format("ID={0} AND IDUpper={1}", pcArgs.rhRowID, pcArgs.rhRowIDUpper))[0]);
}
// Se o nível em questão for uma entidade detentora
if (rhRow == null && nRow.TipoNivelRow.ID == TipoNivel.LOGICO)
{
if (DBAbstractDataLayer.DataAccessRules.NivelRule.Current.isUniqueCodigo(nRow.Codigo, nRow.ID, pcArgs.tran, pcArgs.testOnlyWithinNivel))
{
pcArgs.successful = true;
}
else
{
var cod = nRow.Codigo;
System.Data.DataSet tempgisaBackup1 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup1, ndRow);
pcArgs.gisaBackup = tempgisaBackup1;
System.Data.DataSet tempgisaBackup2 = pcArgs.gisaBackup;
PersistencyHelper.BackupRow(ref tempgisaBackup2, nRow);
pcArgs.gisaBackup = tempgisaBackup2;
ndRow.RejectChanges();
PermissoesHelper.UndoAddNivelGrantPermissions(nRow);
nRow.RejectChanges();
pcArgs.message = string.Format(
"Não é possível completar a operação porque não é permitido " + Environment.NewLine +
"que duas unidades de informação tenham o mesmo código " + Environment.NewLine +
"parcial ({0}) no mesmo nivel de descrição.", cod);
}
}
else
{
// antes de obter o código verificar se adição de um novo nível ainda é possível (por razões
// de concorrência é necessário garantir que tanto o nível acima mantém-se na base de dados
// até o save estar terminado)
bool upperRelationExists;
if (rhRow.IDUpper < 0)
{
upperRelationExists = true;
}
else
{
upperRelationExists = NivelRule.Current.isNivelDeleted(rhRow.IDUpper, args.tran);
}
if (!upperRelationExists)
{
var frdRow = GisaDataSetHelper.GetInstance().FRDBase.Cast <GISADataset.FRDBaseRow>().Single(r => r.ID == pcArgs.frdBaseID);
Nivel.DeleteInDataSet(frdRow, false, pcArgs.gisaBackup);
Nivel.DeleteInDataSet(nRow, false, pcArgs.gisaBackup);
pcArgs.message = "Não foi possível criar/editar a unidade informacional uma" + Environment.NewLine + "vez que a unidade superior foi apagada por outro utilizador.";
}
else
{
if (DBAbstractDataLayer.DataAccessRules.NivelRule.Current.isUniqueCodigo(nRow.Codigo, nRow.ID, pcArgs.tran, pcArgs.testOnlyWithinNivel, rhRow.NivelRowByNivelRelacaoHierarquicaUpper.ID))
{
pcArgs.successful = true;
}
else
{
var cod = nRow.Codigo;
if (nRow.RowState == DataRowState.Modified)
{
nRow.RejectChanges();
GisaDataSetHelper.GetInstance().IndexFRDCA.Cast <GISADataset.IndexFRDCARow>()
.Where(r => r.RowState != DataRowState.Unchanged).ToList().ForEach(r => r.RejectChanges());
}
else if (nRow.RowState == DataRowState.Added)
{
var frdRow = GisaDataSetHelper.GetInstance().FRDBase.Cast <GISADataset.FRDBaseRow>().Single(r => r.ID == pcArgs.frdBaseID);
Nivel.DeleteInDataSet(frdRow, false, pcArgs.gisaBackup);
Nivel.DeleteInDataSet(nRow, false, pcArgs.gisaBackup);
}
pcArgs.message = string.Format(
"Não é possível completar a operação porque não é permitido " + Environment.NewLine +
"que duas unidades de informação tenham o mesmo código " + Environment.NewLine +
"parcial ({0}) no mesmo nivel de descrição.", cod);
}
}
}
}
private void setNewTermo(PersistencyHelper.PreConcArguments args)
{
try
{
PersistencyHelper.ManageFormasAutorizadasPreConcArguments mfaPca = (PersistencyHelper.ManageFormasAutorizadasPreConcArguments)args;
string termo = mfaPca.termo;
GISADataset.ControloAutRow carow = (GISADataset.ControloAutRow)(GisaDataSetHelper.GetInstance().ControloAut.Select("ID=" + mfaPca.caRowID.ToString())[0]);
GISADataset.TipoControloAutFormaRow tcafRowAutorizado = (GISADataset.TipoControloAutFormaRow)(GisaDataSetHelper.GetInstance().TipoControloAutForma.Select("ID=" + System.Enum.Format(typeof(TipoControloAutForma), TipoControloAutForma.FormaAutorizada, "D"))[0]);
DataSet gisaBackup = mfaPca.gisaBackup;
//Dim dataReader As IDataReader
GISADataset.DicionarioRow dRowOrig = null;
GISADataset.ControloAutDicionarioRow cadRowOrig = ControloAutHelper.getFormaAutorizada(carow);
bool existsOrigCad = false;
ArrayList termoUsed = DiplomaModeloRule.Current.GetDicionario(getCatCode(carow.TipoNoticiaAutRow), termo.Trim(), mfaPca.tran);
// Distinguir entre criar e editar um Diploma/Modelo
if (carow.ID < 0)
{
// Criar Diploma/Modelo:
// - verificar se o termo escolhido existe na base de dados e se nesse caso, verificar se
// está a ser utilizado noutro Diploma/Modelo
if (((long)(termoUsed[0])) > 0 && (bool)(termoUsed[1]))
{
// A designação já existe na base de dados mas está marcada como apagada
mfaPca.cadRow = manageDesignacaoDiplomaModelo(mfaPca.cadRow, mfaPca.termo, carow.TipoNoticiaAutRow, carow, tcafRowAutorizado);
}
else if (((long)(termoUsed[0])) > 0 && ! ((bool)(termoUsed[1])))
{
// A designação já existe na base de dados mas não está marcada como apagada; no entanto,
// é preciso saber se está a ser usada por outro Diploma/Modelo (tipicamente, nesta
// situação a designação está a ser utilizada por um Diploma/Modelo mas já aconteceu não
// estar a ser utilizada fruto de uma resolução de conflito de concorrência)
if (DiplomaModeloRule.Current.ExistsControloAutDicionario((long)(termoUsed[0]), 1, carow.TipoNoticiaAutRow.ID, mfaPca.tran))
{
carow.RejectChanges();
mfaPca.message = "A designação especificada já existe, deverá escolhê-la da lista caso a pretenda utilizar.";
}
else
{
mfaPca.cadRow = manageDesignacaoDiplomaModelo(mfaPca.cadRow, mfaPca.termo, carow.TipoNoticiaAutRow, carow, tcafRowAutorizado);
}
}
else
{
// A designação não existe na base de dados
mfaPca.cadRow = manageDesignacaoDiplomaModelo(mfaPca.cadRow, mfaPca.termo, carow.TipoNoticiaAutRow, carow, tcafRowAutorizado);
}
}
else
{
// Editar Diploma/Modelo
// - verificar se entretanto outro utilizador já editou o Diploma/Modelo
// - verificar se o termo escolhido existe na base de dados e se nesse caso, verificar se
// está a ser utilizado noutro Diploma/Modelo
existsOrigCad = DiplomaModeloRule.Current.ExistsControloAutDicionario(cadRowOrig.IDDicionario, cadRowOrig.IDTipoControloAutForma, carow.TipoNoticiaAutRow.ID, mfaPca.tran);
dRowOrig = cadRowOrig.DicionarioRow;
PersistencyHelper.BackupRow(ref gisaBackup, cadRowOrig);
PersistencyHelper.BackupRow(ref gisaBackup, dRowOrig);
cadRowOrig.Delete();
// é permitido apagar o termo antigo uma vez que é único para diplomas/modelo
dRowOrig.Delete();
if (existsOrigCad)
{
// o Diploma/Modelo não foi editado por nenhum outro utilizador
if (((long)(termoUsed[0])) > 0 && (bool)(termoUsed[1]))
{
// A designação já existe na base de dados mas está marcada como apagada
mfaPca.cadRow = manageDesignacaoDiplomaModelo(mfaPca.cadRow, mfaPca.termo, carow.TipoNoticiaAutRow, carow, tcafRowAutorizado);
}
else if (((long)(termoUsed[0])) > 0 && ! ((bool)(termoUsed[1])))
{
// A designação já existe na base de dados mas não está marcada como apagada; no entanto,
// é preciso saber se está a ser usada por outro Diploma/Modelo (tipicamente, nesta
// situação a designação está a ser utilizada por um Diploma/Modelo mas já aconteceu não
// estar a ser utilizada fruto de uma resolução de conflito de concorrência)
if (DiplomaModeloRule.Current.ExistsControloAutDicionario((long)(termoUsed[0]), 1, carow.TipoNoticiaAutRow.ID, mfaPca.tran))
{
dRowOrig.RejectChanges();
cadRowOrig.RejectChanges();
mfaPca.message = "A designação especificada já existe, deverá escolhê-la da lista caso a pretenda utilizar.";
}
else
{
mfaPca.cadRow = manageDesignacaoDiplomaModelo(mfaPca.cadRow, mfaPca.termo, carow.TipoNoticiaAutRow, carow, tcafRowAutorizado);
}
}
else
{
// A designação não existe na base de dados
mfaPca.cadRow = manageDesignacaoDiplomaModelo(mfaPca.cadRow, mfaPca.termo, carow.TipoNoticiaAutRow, carow, tcafRowAutorizado);
}
}
else
{
// Outro utilizador já editou este Diploma/Modelo pelo que não é possível reeditá-lo
dRowOrig.RejectChanges();
cadRowOrig.RejectChanges();
mfaPca.message = "Não foi possível executar a operação pretendida pois o controlo de autoridade foi alterado por outro utilizador.";
}
}
}
catch (Exception ex)
{
Trace.WriteLine(ex);
throw;
}
}