コード例 #1
0
		private static ArrayList getCurrentDatasetChanges(Concorrencia conc)
		{
			//verifica logo à cabeça se houve de facto alguma alteração ao dataset
			if (! (GisaDataSetHelper.GetInstance().HasChanges()))
			{
				return null;
			}

			//obter um arraylist com estruturas que indicam para cada tabela quais as linhas que foram alteradas
            ArrayList changedRowsArrayList = conc.getAlteracoes(GisaDataSetHelper.GetInstance(), DataSetTablesOrderedA);
			if (! (changedRowsArrayList.Count > 0))
			{
				return null;
			}
			else
			{
				return changedRowsArrayList;
			}
		}
コード例 #2
0
		private static void cascadeManageChildDeletedRows(string tableName, ArrayList rows, Concorrencia conc, IDbTransaction tran)
		{
			ArrayList rowsToBeSaved = new ArrayList();
			DBAbstractDataLayer.DataAccessRules.ConcorrenciaRule.ChildRelationRows childRelRows = new DBAbstractDataLayer.DataAccessRules.ConcorrenciaRule.ChildRelationRows();
			childRelRows = DBAbstractDataLayer.DataAccessRules.ConcorrenciaRule.Current.getChildRowsFromDB(GisaDataSetHelper.GetInstance(), GisaDataSetHelper.GetInstance().Tables[tableName], rows, tran); // obter as linhas filhas das linhas eliminadas, podem também elas precisar de ser eliminadas
			// iterar sobre todas as tabelas filhas (no DS) da recebida em tableName
//INSTANT C# NOTE: The ending condition of VB 'For' loops is tested only on entry to the loop. Instant C# has created a temporary variable in order to use the initial value of childRelRows.tables.Count for every iteration:
			int tempFor1 = childRelRows.tables.Count;
			for (int i = 0; i < tempFor1; i++)
			{
				DataTable childTable = (DataTable)(childRelRows.tables[i]);
				rowsToBeSaved.Clear();
				// iterar sobre todas as linhas das tabelas filhas
				foreach (DataRow row in childTable.Rows)
				{

					if (! (makeNullableColumnsNull(row, (DataColumn[])(childRelRows.relationColumns[i]))))
					{
						cascadeManageChildDeletedRows(childTable.TableName, new ArrayList(new DataRow[] {row}), conc, tran);
						row["isDeleted"] = 1;
					}
					rowsToBeSaved.Add(row);
				}
				PersistencyHelperRule.Current.saveRows(GisaDataSetHelper.GetInstance().Tables[childTable.TableName], (DataRow[])(rowsToBeSaved.ToArray(typeof(DataRow))), tran);
			}
		}
コード例 #3
0
        public static SaveResult save(PreTransactionAction preTransactionAction, preConcDelegate pcDelegate, PreConcArguments pcArguments, preSaveDelegate psDelegate, PreSaveArguments psArguments, PostSaveAction postSaveAction, bool activateOpcaoCancelar)
		{
			Concorrencia conc = new Concorrencia();
			IDbTransaction tran = null;
            SaveResult successfulSave = SaveResult.successful;
			GisaDataSetHelper.HoldOpen ho = null;
			long startTicks = 0;
			bool savedWithoutDeadlock = false;
			// Variavel que indica qual a tabela que está a ser gravada (tem o debugging como fim)
			string currentTable = string.Empty;
			DataSet gBackup = null;
			ArrayList changedRowsArrayList = null;
			// Variável que vai manter a informação das linhas "added" cujos Ids são gerados automaticamente
			// antes e depois de serem gravadas (antes de essas linhas serem gravadas os seus IDs são
			// negativos e depois são-lhe atribuidos valores positivos
			Hashtable trackNewIds = new Hashtable();

            try
            {
                if (preTransactionAction != null)
                {
                    preTransactionAction.ExecuteAction();
                    if (preTransactionAction.args.cancelAction)
                    {
                        MessageBox.Show(preTransactionAction.args.message, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        GisaDataSetHelper.GetInstance().RejectChanges();
                        return SaveResult.nothingToSave;
                    }
                }
            }
            catch (Exception e) { 
                Trace.WriteLine(e.ToString());
                return SaveResult.unsuccessful; }
            finally { }



			while (! savedWithoutDeadlock)
			{
				try
				{
					if (pcDelegate != null)
					{
						ho = new GisaDataSetHelper.HoldOpen(GisaDataSetHelper.GetConnection());
						tran = ho.Connection.BeginTransaction(GisaDataSetHelper.GetTransactionIsolationLevel());
						pcArguments.tran = tran;
						gBackup = new DataSet();
						gBackup.CaseSensitive = true;
						pcArguments.gisaBackup = gBackup;
						pcArguments.continueSave = true;
						pcDelegate(pcArguments);

						//no caso de se pretender apagar uma relacao hierarquica ha a possibilidade de 
						//não ser necessário prosseguir com a gravação dos dados por razoes de logica
						//(ver o delegate verifyIfCanDeleteRH)
						if (! pcArguments.continueSave)
						{
							tran.Commit();
							savedWithoutDeadlock = true;
                            successfulSave = SaveResult.unsuccessful;
                            break;
						}
					}

					//verifica logo à cabeça se houve de facto alguma alteração ao dataset
					if (! (GisaDataSetHelper.GetInstance().HasChanges()))
					{
                        return SaveResult.nothingToSave;
					}

					//obter um arraylist com estruturas que indicam para cada tabela quais as linhas que foram alteradas
					changedRowsArrayList = getCurrentDatasetChanges(conc);
					if (changedRowsArrayList == null)
					{
                        return SaveResult.nothingToSave;
					}

					while (true)
					{
						if (ho == null)
						{
							ho = new GisaDataSetHelper.HoldOpen(GisaDataSetHelper.GetConnection());
						}
						if (tran == null)
						{
							tran = ho.Connection.BeginTransaction(GisaDataSetHelper.GetTransactionIsolationLevel());
						}

						//manter 2 datasets com linhas provenientes da bd
						//isto para permitir a detecção de novos e possiveis conflitos qd o utilizador perante 1 problema de concorrencia pretende manter as suas alterações
						//a estratégia passa por verificar se houve alterações no 1º (e principal) dataset com as linhas da bd
						if (originalRowsDB1 == null)
						{
							//guardar as linhas neste dataset

							//FIXME: changedRowsArrayList esta a chegar com tabelas repetidas (!)
							originalRowsDB1 = conc.getOriginalRowsDB(changedRowsArrayList, tran);
						}
						else if (originalRowsDB1 != null && originalRowsDB2 == null)
						{
							//o dataset principal (originalRowsDB1) ja esta preenchido e o utilizador pretende manter as suas alterações

							//o dataset principal (originalRowsDB1) ja esta preenchido e o utilizador pretende manter as suas alterações
							// as linhas da BD vao parar ao 2º dataset
							originalRowsDB2 = conc.getOriginalRowsDB(changedRowsArrayList, tran);



							if (originalRowsDB2 == null)
							{
								originalRowsDB1 = null;
							}
						}
						else if (originalRowsDB1 != null && originalRowsDB2 != null)
						{
							//os 2 datasets estao preenchidos (o que quer dizer que estamos perante a 2ª situação de concorrencia consecutiva (no mínimo) na mesma mudança de contexto)

							//nesta situação o dataset principal passa a ter as alterações contidas no 2º para que neste último passem a constar os novos dados provenientes da BD
							//se não existirem novas linhas, quer dizer que as alterações feitas em memória coincidem com aquelas existentes na BD

							//verificar se existem novas linhas
							if (! (conc.getOriginalRowsDB(changedRowsArrayList, tran) == null))
							{
								originalRowsDB1 = originalRowsDB2.Copy();
								originalRowsDB2 = conc.getOriginalRowsDB(changedRowsArrayList, tran);
							}
							else
							{
								originalRowsDB1 = null;
								originalRowsDB2 = null;
							}
						}

						//se não existirem conflitos de concorrencia
						if (! ((originalRowsDB1 != null && originalRowsDB2 == null && conc.temLinhas(originalRowsDB1)) || (originalRowsDB1 != null && originalRowsDB2 != null && conc.wasModified(originalRowsDB1, originalRowsDB2, changedRowsArrayList))))
						{
							//não há concorrência quando o originalRowsDB1 não tem linhas e originalRowsDB2 está vazio ou quando os dois datasets são diferentes

							break;
						}
						else
						{
							//caso existam conflitos, é apresentado ao utilizador uma mensagem a indicar os pontos de conflito e de que forma os pretende resolver


							//ToDo: verificar a necessidade de fazer rollback
							tran.Rollback();
							ho.Dispose();
							ho = null;
							tran = null;

							frm.DetalhesUser = Concorrencia.StrConcorrenciaUser.ToString();
							frm.DetalhesBD = Concorrencia.StrConcorrenciaBD.ToString();
							frm.btnCancel.Enabled = activateOpcaoCancelar;

							switch (frm.ShowDialog())
							{
								case DialogResult.Yes:
									//mantem-se dentro do ciclo de forma a voltar a verificar se existe concorrencia ou nao
									//ao mesmo tempo que este tratamento de conflitos e executado outro utilizador pode já ter feito novas alterações                           

									//é necessario limpar as variaveis que mantem as mensagens sobre a concorrencia para o caso de neste situação ainda existirem novos situações de conflito
									Concorrencia.StrConcorrenciaBD.Remove(0, Concorrencia.StrConcorrenciaBD.Length);
									Concorrencia.StrConcorrenciaUser.Remove(0, Concorrencia.StrConcorrenciaUser.Length);

									break;
								case DialogResult.No:
									//gravar em memoria as linhas obtidas da base de dados e sai do metodo
									if (originalRowsDB2 != null)
									{
										//se no dataset originalRowsDB2 existirem linhas, logo é este que vai ser gravado
										conc.MergeDatasets(originalRowsDB2, GisaDataSetHelper.GetInstance(), DataSetTablesOrderedA);
									}
									else
									{
                                        conc.MergeDatasets(originalRowsDB1, GisaDataSetHelper.GetInstance(), DataSetTablesOrderedA);
									}
									conc.ClearRowsChangedToModified();
									cleanConcurrencyVariables();

									return successfulSave;
								case DialogResult.Cancel:
									cleanConcurrencyVariables();

                                    successfulSave = SaveResult.cancel;
									return successfulSave;
							}
						}
					}

					startTicks = DateTime.Now.Ticks;

					if (Concorrencia.StrConcorrenciaLinhasNaoGravadas.Length > 0)
					{
						MessageBox.Show("A informação referente aos campos seguintes não pode ser gravada " + Environment.NewLine + "por ter sido, entretanto, eliminada: " + System.Environment.NewLine + Concorrencia.StrConcorrenciaLinhasNaoGravadas.ToString(), "Gravação de dados.");
					}

					// Chamar qualquer tarefa de "pré-gravação" que possa ter sido definida
					if (psDelegate != null)
					{
						psArguments.tran = tran;
						psDelegate(psArguments);
					}

					// forma de manter a informação referente à actualização dos Ids das linhas quando 
					// estas são adicionadas na base de dados, isto é, saber qual o valor (negativo) 
					// do ID antes da linha ser gravada e o valor (positivo) atribuído pela base de dados
					// depois do save
					trackNewIds.Clear();
					conc.startTrackingIdsAddedRows(GisaDataSetHelper.GetInstance(), changedRowsArrayList, ref trackNewIds);

					// garantir que filhos das linhas a eliminar que não estão carregados ficam também eles eliminados
					//ToDo: em getChildRowsFromDB utilizar dataset de trabalho para obter as relações entre tabelas. Passar ao metodo o origRowsDB para que as linhas obtidas lhe sejam directamente adicionadas
					ArrayList rows = new ArrayList();
					ArrayList afectedTables = new ArrayList();
					GisaDataSetHelper.ManageDatasetConstraints(false);
					foreach (Concorrencia.changedRows changedRow in changedRowsArrayList)
					{
						currentTable = changedRow.tab;
						if (changedRow.rowsDel.Count > 0)
						{
							cascadeManageChildDeletedRows(changedRow.tab, changedRow.rowsDel, conc, tran);
						}

						// alterar o estado das Rowstate.Deleted para Rowstate.Unchanged e passa-las a isDeleted=True
						DataRow delRow = null;

						if (changedRow.rowsDel.Count > 0)
						{

							while (changedRow.rowsDel.Count > 0)
							{
                                if (changedRow.tab.Equals("ControloAutDataDeDescricao") || changedRow.tab.Equals("FRDBaseDataDeDescricao"))
                                {
                                    delRow = (DataRow)(changedRow.rowsDel[0]);
                                    delRow.RejectChanges();
                                    changedRow.rowsDel.RemoveAt(0);
                                }
                                else
                                {
                                    delRow = (DataRow)(changedRow.rowsDel[0]);
                                    delRow.RejectChanges();
                                    delRow["isDeleted"] = 1;
                                    changedRow.rowsMod.Add(delRow);
                                    changedRow.rowsDel.RemoveAt(0);
                                }
							}
						}

						rows.Clear();
						rows.AddRange(changedRow.rowsAdd);
						rows.AddRange(changedRow.rowsMod);
						PersistencyHelperRule.Current.saveRows(GisaDataSetHelper.GetInstance().Tables[changedRow.tab], (DataRow[])(rows.ToArray(typeof(DataRow))), tran);
					}

                    if (postSaveAction != null)
                    {
                        postSaveAction.args.tran = tran;
                        postSaveAction.ExecuteAction();
                    }

					conc.ClearRowsChangedToModified();
					GisaDataSetHelper.ManageDatasetConstraints(true);
					tran.Commit();
					savedWithoutDeadlock = true;
					Debug.WriteLine("Save: " + new TimeSpan(DateTime.Now.Ticks - startTicks).ToString());
					Trace.WriteLine("Save completed.");
				}
				catch (Exception ex)
				{
                    Trace.WriteLine(ex);

					//GisaDataSetHelper.GetInstance().RejectChanges()
					if (DBAbstractDataLayer.DataAccessRules.ExceptionHelper.isDeadlockException(ex))
					{
						Trace.WriteLine(">>> Deadlock (save).");
						conc.prepareRollBackDataSet(ref trackNewIds);
						tran.Rollback();
						tran = null;
						if (conc.mGisaBackup != null && gBackup != null)
						{
                            conc.MergeDatasets(gBackup, conc.gisabackup, DataSetTablesOrderedA);
						}
						if (conc.mGisaBackup != null)
						{
                            conc.MergeDatasets(conc.mGisaBackup, GisaDataSetHelper.GetInstance(), DataSetTablesOrderedA, trackNewIds);
						}
						conc.deleteUnusedRows(GisaDataSetHelper.GetInstance(), ref trackNewIds);
						gBackup = null;
					}
					else if (DBAbstractDataLayer.DataAccessRules.ExceptionHelper.isTimeoutException(ex))
					{
						Trace.WriteLine(">>> Timeout (save).");
						conc.prepareRollBackDataSet(ref trackNewIds);
						tran = null;
						if (conc.mGisaBackup != null && gBackup != null)
						{
                            conc.MergeDatasets(gBackup, conc.gisabackup, DataSetTablesOrderedA);
						}
						if (conc.mGisaBackup != null)
						{
                            conc.MergeDatasets(conc.mGisaBackup, GisaDataSetHelper.GetInstance(), DataSetTablesOrderedA, trackNewIds);
						}
						conc.deleteUnusedRows(GisaDataSetHelper.GetInstance(), ref trackNewIds);
						gBackup = null;
					}
					else
					{
	#if DEBUG
						Trace.WriteLine(currentTable);
	#endif
						Trace.WriteLine("Save failed.");
						Trace.WriteLine(ex);
						Debug.Assert(false, "Save failed.");

						if (tran != null)
						{
							tran.Rollback();
						}
						tran = null;

						MessageBox.Show("Ocorreu um erro inesperado durante a gravação " + Environment.NewLine + "da informação e por esse motivo a aplicação irá " + Environment.NewLine + "fechar. Por favor contacte o administrador do sistema", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        throw;
					}
				}
				finally
				{
					if (tran != null)
					{
						tran.Dispose();
					}

					cleanConcurrencyVariables();

					if (savedWithoutDeadlock)
					{
						conc.mGisaBackup = null;
					}

					if (ho != null)
					{
						ho.Dispose();
						ho = null;
					}
				}
			}


			return successfulSave;
		}