sabato 14 giugno 2008

Eseguire query in transazione

A chi non è mai capitato di dover effettuare operazioni (interrogazioni a db e inserimenti) legate tra di loro e di doversi servire di una transazioni per gestire la concorrenzialità sulla modifica dei dati da più connessioni?

Nel caso di DNN è abbastanza semplice prevedere la possibilità di utilizzare connessioni in transazione per effettuare operazioni tra di loro collegate ad esempio se ci fosse la necessità di leggere un dato da una tabella e scriverlo su un'altra evitando che possa essere modificato nel frattempo. in alternativa all'utilizzo di un store procedure possiamo implementare un metodo nel nostro data provider come quello che segue:

Public Overrides Function MyTransactionFunction() As string

Dim Exceptions As String = ""
Dim strQuery As String = ""
Dim s As StringBuilder = New StringBuilder("")
Dim Conn As New SqlConnection(ConnectionString)

Conn.Open()
Try
Dim Trans As SqlTransaction = Conn.BeginTransaction
Dim IgnoreErrors As Boolean
Dim ReturnedValue as integer
Try
'Prima query
s.Append("select myval ")
s.Append(" from " & DatabaseOwner & ObjectQualifier & "MyTab ")
ReturnedValue = SqlHelper.ExecuteScalar(ConnectionString, CommandType.Text, s.ToString)

'Seconda query
s = New StringBuilder("")
s.Append(" insert into ")
s.Append(DatabaseOwner & ObjectQualifier)
s.Append("My_Table ")
s.Append(" (col1,ReturnedValue) ")
s.Append(" values (")
s.Append(val1)
s.Append(",")
s.Append(ReturnedValue)
s.Append("')")
strQuery = s.ToString()
sqlDR = SqlHelper.ExecuteNonQuery(ConnectionString, CommandType.Text, (strQuery))

Catch objException As SqlException
Exceptions += objException.ToString & vbCrLf & vbCrLf & strQuery & vbCrLf & vbCrLf
End Try

If Exceptions.Length = 0 Then
Trans.Commit()
Return "1"
Else
Trans.Rollback()
Exceptions += "Esecuzione SQL fallita. La transazione è stata annullata." & vbCrLf & vbCrLf & strQuery & vbCrLf & vbCrLf
Return Exceptions
End If
Catch objException As SqlException
Exceptions += objException.ToString & vbCrLf & vbCrLf & strQuery & vbCrLf & vbCrLf
objExeptionLog.AddLog(objException)
Finally
Conn.Close()
End Try

Return Exceptions
End Function
Come si vede dal codice viene istanziata una transazione e utilizzata sulla connessione al db per tutte le operazioni effettuate nel metodo. In questo modo è semplice gestire il rollback in caso di eventuali errori e il commit in caso di successo.

giovedì 12 giugno 2008

Permessi personalizzati per i moduli

Oggi affrontiamo il problema dei permessi ed in particolare come è possibile aggiungere ad un modulo custom dei permessi aggiuntivi oltre a quelli di default.

Innanzi tutto facciamo qualche premessa. In base a quanto detto nei post precedenti per la creazione di un modulo custom con l'ausilio dello StarterKit partiamo dalla situazione in cui abbiamo configurato il nostro modulo aggiungendolo ad una pagina.

Se tutto è andato bene dovremmo essere di fronte a qualche cosa del genere:

Come vedete nella colonna centrale è presente il nostro modulo dimostrativo. A questo punto possiamo iniziare ad insererire all'interno del nostro modulo il codice necessario per aggiungere i permessi.

Il codice da inserire riguarda il nostro controller principale, DemoModuleController che si trova nella directory App_Data.

All' interno di questo controller possiamo aggiungere il codice riportato di seguito lasciando inalterati i metodi già esistenti:


Imports System
Imports System.Configuration
Imports System.Data
Imports System.XML
Imports System.Web
Imports System.Collections.Generic
Imports DotNetNuke
Imports DotNetNuke.Services.Search
Imports DotNetNuke.Common.Utilities.XmlUtils
Imports DotNetNuke.Entities.Modules
Imports DotNetNuke.Entities.Modules.Definitions

Namespace DotNetNukeIta.Modules.DemoModule

'''
''' The Controller class for DemoModule
'''

'''
'''

'''
'''

''' ------------------------------------------
Public Class DemoModuleController
Implements Entities.Modules.ISearchable
Implements Entities.Modules.IPortable

#Region "Variabili Private"
Private _PremessoDemo As Boolean
#End Region

#Region "Costanti pubbliche"
Public Const PERMISSIONCODE As String = "DemoModule"

Public Const PERMESSODEMO As String = "PERMESSODEMO"
#End Region

#Region "Private Methods"

Private Sub InitModulePermissions()

Dim permCtl As Permissions.PermissionController = New Permissions.PermissionController()
Dim arr As ArrayList = permCtl.GetPermissionByCodeAndKey(PERMISSIONCODE, "")
Dim desktopMod As DesktopModuleController = New DesktopModuleController()
Dim desktopInfo As DesktopModuleInfo = desktopMod.GetDesktopModuleByModuleName("DotNetNukeIta.DemoModule")
Dim modDef As ModuleDefinitionController = New ModuleDefinitionController()
Dim modDefInfo As ModuleDefinitionInfo = modDef.GetModuleDefinitionByName(desktopInfo.DesktopModuleID, "GECO")

'Settaggio permessi sulle Pagine AnagraficaPF
Try
Dim pi As Permissions.PermissionInfo = New Permissions.PermissionInfo()
pi.ModuleDefID = modDefInfo.ModuleDefID
pi.PermissionCode = PERMISSIONCODE
pi.PermissionKey = PERMESSODEMO
pi.PermissionName = "Permesso personalizzato"
permCtl.AddPermission(pi)
Catch e As Exception
' gestisco l'eventuale eccezione
End Try

End Sub

#End Region

#Region "Metodi Pubblici"

Public Function UpgradeModule(ByVal Version As String) As String
'Possiamo impostare un controllo a piacere
' in questo caso controlliamo il numero di versione del modulo
' e istalliamo i permessi solo se il modulo è alla versione 01.00.00
If (Version = "01.00.00") Then
' Istallazione dei permessi per il modulo
InitModulePermissions()
End If

'Se tutto è andato bene aggiorno la versione del modulo
Version = "01.00.01"
Return Version
End Function

Public ReadOnly Property PermessoDiDemo() As Boolean
Get
Return _PremessoDemo
End Get
End Property

''' Esempio di utilizzo :
'''
''' Dim ms As DemoModuleController = New GECOController()
''' Dim objModules As ModuleController = New ModuleController()
''' Dim objMudule As ModuleInfo
''' objMudule = objModules.GetModule(ModuleId, TabId)
''' ms.ModuleSecurity(objMudule)
'''-----------------------------------------------------------
Public Sub ModuleSecurity(ByVal modInfo As ModuleInfo)
Dim permCollection As Permissions.ModulePermissionCollection

permCollection = modInfo.ModulePermissions
Dim permCtl As Permissions.ModulePermissionController = New Permissions.ModulePermissionController()
_PremessoDemo = Permissions.ModulePermissionController.HasModulePermission(permCollection, PERMESSODEMO)

End Sub

#End Region


La Sub InitModulePermissions consente di inizializzare la definizione dei permessi per il nostro modulo. Possiamo quindi pensare di chiamarla quando più ci fa comodo, per esempio all'istallazione o all'aggiornamento del modulo stesso.

Una volta inseriti i permessi accedendo alle impostazioni del modulo (icona in alto a sinistra del modulo, settings) avremo il permesso tra quelli disponibili come appare di seguito:

Prima:

Dopo:

Come vedete si è aggiunta una colonna col il nuovo permesso. A questo punto dalle nostre pagina possiamo richiamare il metodo per controllare i permessi:



'*****controllo permessi*****
Dim ms As DemoModuleController
Dim objModules As ModuleController
Dim objMudule As ModuleInfo

ms = New DemoModuleController()
objModules = New ModuleController()

objMudule = objModules.GetModule(ModuleId, TabId, False)
ms.ModuleSecurity(objMudule)

If ms.PermessoDiDemo = False Then
Response.Redirect(NavigateURL())
End If
'*****controllo permessi*****


Ed il gioco è fatto ...

martedì 3 giugno 2008

DotNetNuke - StarterKit

DotNetNuke mette a disposizione uno strumento molto utile per iniziare a sviluppare moduli personalizzati. Si tratta dello StarterKit che una volta istallato aggiunge a VisualStudio (2005, 2008, Express) dei nuovi elementi da aggiungere ad un progetto web. Vediamo innanzi tutto come poter istallare il kit. Andiamo sul sito di DNN e scarichiamo (previo login al sito) lo StarterKit più recente che, una volta scaricato, dovrebbe apparire più o meno così:


Lanciamo l'eseguibile appena scaricato e ci troviamo di fronte ad una finestra come questa:



Clicchiamo su AVANTI:


Confermiamo premendo YES per andare avanti con l'istallazione:

A questo punto terminiamo premendo CLOSE e lanciamo Visual Studio per iniziare il nostro nuovo progetto DotNetNuke. Dal manù FILE scegliamo l'opzione "New Web Site". Tra le voci disponibili troviamo "DotNetNuke Web Application Framework". Scegliamo una cartella e premiamo OK.

A questo punto avremo a disposizione un progetto vuoto con tutti i file necessari per iniziare a sviluppare i nostri moduli personalizzati sfruttando le API di DNN. Appena caricato il progetto si presenta una pagina in cui ci sono delle ottime spiegazioni per configurare la connessione al database ed effettuare le prime customizzazioni grafiche (link: come configurare il database)

A questo punto sempre sfruttando lo StarterKit istallato per Visual Studio possiamo aggiungere altri elementi al nonstro progetto. Partiamo dall'aggiunta di un nuovo tema per il nostro portale. Claccando con il tasto destro del mouse sulla root del progetto in "Solution Explorer" scegliamo la voce "Add new item". Scegliamo "DotNetNuke Skin" e diamo un nome al nostro tema.

Premiamo ADD e il wizard aggiungerà i file di base per iniziare a creare il nostro tema personalizzato. Importantissimo è leggere le spiegazioni che appaiono nella pagina di documentazione. Il wizard di Visual Studio non è in grado di cambiare il nome alle directory dei file template, quindi questa operazione la dobbiamo fare a mano.

Cambiamo il nome delle cartelle 'SkinName' con il nome che abbiamo scelto per il nostro tema (in questo caso abbiamo scelto 'DemoSkin'). Come possiamo notare abbiamo due cartelle, Containers e Skins, all'interno delle quali ci sono i file dedicati alla personalizzazione del tema del portale e dei container. I container sono le parti del portale che contengono i moduli e possono essere personalizzate applicando degli stili in maniera indipendente dagli stili applicati al portale. In poche parole nella cartella Skins andiamo ad inserire i temi relativi all'aspetto del portale (header, footer, content ecc.), mentre nella cartella Containers inseriamo i temi relativi alla definizione dello stile del contenuto del portale. Nei prossimi post vedremo come personalizzare i temi e quali sono le parti principali su cui effettuare le modifiche.

Se volessimo aggiungere un nuovo modulo personalizzato possiamo operare come abbiamo per il tema cliccando con il tasto destro del mouse sulla root del progetto e scegliendo "Add new item". Scegliamo "DotNetNuke Dynamic Module" e diamo un nome al nostro Modulo. Premiamo ADD e andiamo avanti.A questo punto il wizard creerà i file di base per il modulo da cui iniziare con lo sviluppo.

Come per il tema vengono creati i file necessari sia nella cartella App_Code sia nella cartella DesktopModules e come per i temi dobbiamo cambiare il nome della cartella 'ModuleName' con il nome che abbiamo scelto per il modulo (in questo caso DemoModule). Nei prossimi moduli approfondiremo su come approcciare lo sviluppo di moduli custom con DNN.

Per ora è tutto ... al prossimo post.