//------------------------------------------------------------------------------------------------
public static CResultAErreur CreateDatabase(IDatabaseConnexion connexion)
{
CResultAErreur result = CResultAErreur.True;
if (!connexion.IsConnexionValide())
{
if (connexion is COleDbDatabaseConnexion)
{
string strConnexionString = connexion.ConnexionString;
//Trouve le nom de la base
Regex findName = new Regex("Data Source[ ]*=[ ]*(.*);?", RegexOptions.IgnoreCase);
Match match = findName.Match(strConnexionString);
string strBase = "";
if (match != null)
{
strBase = match.Value;
string[] strVals = strBase.Split('=');
if (strVals.Length > 1)
{
strBase = strVals[1].Split(';') [0];
}
}
if (!File.Exists(strBase))
{
System.Reflection.Assembly thisExe;
thisExe = System.Reflection.Assembly.GetExecutingAssembly();
Stream source =
thisExe.GetManifestResourceStream("sc2i.data.serveur.BASEVIDE.MDB");
if (strBase == "")
{
result.EmpileErreur(I.T("Impossible to determine the database name|123"));
return(result);
}
Stream dest = new FileStream(strBase, FileMode.CreateNew);
result = CStreamCopieur.CopyStream(source, dest, 2048);
dest.Close();
if (!result)
{
return(result);
}
}
}
else
{
result.EmpileErreur(I.T("'CreateDatabase' function not possible for connection @1|124", connexion.GetType().Name));
}
}
return(result);
}
public CResultAErreur CopieFichierEnLocal(string strNomFichierLocal)
{
CResultAErreur result = CResultAErreur.True;
if (m_referenceAttachee == null)
{
return(result);
}
result = CDocumentGED.GetDocument(m_nIdSession, m_referenceAttachee);
if (!result)
{
return(result);
}
CSourceDocumentStream source = result.Data as CSourceDocumentStream;
if (source != null)
{
m_fichierLocal.Extension = m_referenceAttachee.GetExtension();
m_fichierLocal.CreateNewFichier(strNomFichierLocal);
m_strNomFichierLocal = m_fichierLocal.NomFichier;
FileStream stream = new System.IO.FileStream(m_fichierLocal.NomFichier, System.IO.FileMode.Create);
result = CStreamCopieur.CopyStream(source.SourceStream, stream, 32000);
stream.Close();
stream.Dispose();
source.SourceStream.Close();
source.Dispose();
m_dateTimeFichierInGed = File.GetLastWriteTime(m_strNomFichierLocal);
return(result);
}
CSourceDocumentLienDirect sourceDirecte = result.Data as CSourceDocumentLienDirect;
if (sourceDirecte != null)
{
m_typeReferencePourGed = CTypeReferenceDocument.TypesReference.LienDirect;
m_strNomFichierLocal = sourceDirecte.NomFichier;
return(result);
}
return(result);
}
//-------------------------------------------------------------------
public CResultAErreur SaveDocument(CSourceDocument source,
CTypeReferenceDocument typeReference,
CReferenceDocument versionPrecedente,
bool bIncrementeVersionFichier)
{
CResultAErreur result = CResultAErreur.True;
//Copie du fichier
try
{
switch (typeReference.Code)
{
case CTypeReferenceDocument.TypesReference.Fichier:
if (!(source is CSourceDocumentStream))
{
result.EmpileErreur(I.T("Document type '@1' source not supported|109", source.GetType().Name));
return(result);
}
string strNomFichier = "";
if (versionPrecedente != null)
{
strNomFichier = versionPrecedente.NomFichier;
strNomFichier = strNomFichier.Replace("..", "."); //Correction erreurs passées
if (bIncrementeVersionFichier)
{
strNomFichier = IncNomFichier(strNomFichier);
}
string strExt = ((CSourceDocumentStream)source).Extension;
if (strExt.ToUpper() != "DAT")
{
strNomFichier = ChangeExtension(strNomFichier, ((CSourceDocumentStream)source).Extension);
}
}
else
{
string strPath = DateTime.Now.Year.ToString() + "\\";
strPath += DateTime.Now.Month.ToString() + "\\";
strPath += DateTime.Now.Day.ToString() + "\\";
strNomFichier = strPath + CGenerateurStringUnique.GetNewNumero(m_nIdSession) + "_0.";
strNomFichier += ((CSourceDocumentStream)source).Extension;
}
//S'assure que le chemin du fichier existe
string[] strChemins = strNomFichier.Split('\\');
int nChemin = 0;
string strTemp = m_strPath;
foreach (string strChemin in strChemins)
{
if (nChemin < strChemins.Length - 1)
{
if (!Directory.Exists(m_strPath + strChemin))
{
Directory.CreateDirectory(strTemp + strChemin);
}
strTemp += strChemin + "\\";
}
nChemin++;
}
if (strNomFichier.LastIndexOf('.') < 0)
{
strNomFichier += ((CSourceDocumentStream)source).Extension;
}
if (File.Exists(m_strPath + strNomFichier))
{
File.Delete(m_strPath + strNomFichier);
}
FileStream stream = new FileStream(m_strPath + strNomFichier, FileMode.CreateNew);
Stream sourceStream = ((CSourceDocumentStream)source).SourceStream;
result = CStreamCopieur.CopyStream(sourceStream, stream, 32000);
if (!result)
{
File.Delete(strNomFichier);
return(result);
}
CReferenceDocument referenceFinale = new CReferenceDocument();
referenceFinale.NomFichier = strNomFichier;
referenceFinale.CodeTypeReference = CTypeReferenceDocument.TypesReference.Fichier;
referenceFinale.TailleFichier = (int)new FileInfo(m_strPath + strNomFichier).Length;
m_listeReferencesTemporaires.Add(new CReferenceTemporaire(referenceFinale));
if (m_timerNettoyage == null && C2iAppliServeur.GetValeur(c_cleDesactivationNettoyage) != null)
{
m_timerNettoyage = new Timer(new TimerCallback(NettoyageTemporaires), null, 1000 * 60 * 30, 1000 * 60 * 30);
}
result.Data = referenceFinale;
break;
case CTypeReferenceDocument.TypesReference.LienDirect:
//Vérifie que le lien est accessible depuis le serveur
CSourceDocumentLienDirect sourceDirecte = source as CSourceDocumentLienDirect;
if (sourceDirecte == null)
{
result.EmpileErreur(I.T("Document type '@1' source not supported|109", source.GetType().Name));
return(result);
}
CReferenceDocument referenceFinaleLien = new CReferenceDocument();
referenceFinaleLien.NomFichier = sourceDirecte.NomFichier;
referenceFinaleLien.CodeTypeReference = CTypeReferenceDocument.TypesReference.LienDirect;
referenceFinaleLien.TailleFichier = (int)new FileInfo(sourceDirecte.NomFichier).Length;
if (!File.Exists(sourceDirecte.NomFichier))
{
result.EmpileErreur("File @1 cannot be stored in EDM, it can not be reached from server|20000", sourceDirecte.NomFichier);
return(result);
}
result.Data = referenceFinaleLien;
break;
default:
result.EmpileErreur(I.T("File reference type @1 not supported|110", typeReference.ToString()));
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while saving EDM |111"));
}
return(result);
}
/// //////////////////////////////////////////////
public CResultAErreur Export(DataSet ds, IDestinationExport destination)
{
CResultAErreur result = CResultAErreur.True;
if (!(destination is CDestinationExportFile))
{
result.EmpileErreur(I.T("An Access export can be done only in a file|168"));
return(result);
}
string strNomFichier = ((CDestinationExportFile)destination).FileName;
try
{
CalculeLongueurMaxChampsTexte(ds);
ds.EnforceConstraints = false;
System.Reflection.Assembly thisExe;
thisExe = System.Reflection.Assembly.GetExecutingAssembly();
Stream source =
thisExe.GetManifestResourceStream(GetNomRessourceForVersion());
if (File.Exists(strNomFichier))
{
File.Delete(strNomFichier);
}
Stream dest = new FileStream(strNomFichier, FileMode.CreateNew);
result = CStreamCopieur.CopyStream(source, dest, 2048);
dest.Close();
if (!result)
{
return(result);
}
m_connection = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data Source=" +
strNomFichier +
";Mode=Share Deny None;Extended Properties=\"\";" +
"Jet OLEDB:System database=\"\";Jet OLEDB:Registry Path=\"\";" +
"Jet OLEDB:Engine Type=4;Jet OLEDB:Database Locking Mode=0;" +
"Jet OLEDB:Global Partial Bulk Ops=2;Jet OLEDB:Global Bulk Transactions=1;" +
"Jet OLEDB:Create System Database=False;Jet OLEDB:Encrypt Database=False;" +
"Jet OLEDB:Don't Copy Locale on Compact=False;Jet OLEDB:Compact Without Replica Repair=False;Jet OLEDB:SFP=False");
m_connection.Open();
m_transaction = m_connection.BeginTransaction();
//Nom de table->true : pour éviter 2 fois le même nom de table
Hashtable tableTablesCrees = new Hashtable();
foreach (DataTable table in ds.Tables)
{
result = CreateTable(table, tableTablesCrees);
if (!result)
{
break;
}
}
if (result)
{
if (!m_bOnlyStructure)
{
foreach (DataTable table in ds.Tables)
{
result = CreateData(table);
if (!result)
{
break;
}
}
}
if (result)
{
m_transaction.Commit();
m_transaction = m_connection.BeginTransaction();
int nNumRelation = 0;
foreach (DataRelation relation in ds.Relations)
{
result = CreateForeignKeys(relation, nNumRelation++);
if (!result)
{
break;
}
}
}
}
if (result)
{
m_transaction.Commit();
}
else
{
m_transaction.Rollback();
}
m_connection.Close();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
finally
{
ds.EnforceConstraints = true;
}
return(result);
}
