This Blog

Syndication

Search

Tags

Community

Email Notifications

Archives

Enlaces Recomendados

October 2011 - Artículos

SharePoint 2010: Capacidades de Enterprise Content Management (I)!

Como sabéis, una de las áreas de funcionalidad de SharePoint Server 2010 (desde la versión estándar) es la de gestión de contenidos empresariales o ECM (Enterprise Content Management) que en la última versión de nuestro servidor favorito viene con un montón de novedades muchas de las cuales se recogen en la correspondiente sección de MSND: http://msdn.microsoft.com/es-es/library/ee554868.aspx. Aparte de esta referencia clave, en el blog del CIIN se han escrito ya varios artículos (vendrán más) en torno a ECM que paso a resumiros (seguro que me habré dejado alguno por el camino):

Organización de contenido

Tipos de contenido

Tipos de contenido empresariales

Document Sets

Metadatos administrados

Otros posts

Publicado 15/10/2011 11:08 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

SQL Azure: Creación de informes con SQL Azure Reporting (I)!

Como comentaba ayer el amigo Ibón, uno de los anuncios que ha hecho Microsoft con respecto a SQL Azure es que por fin tenemos la posibilidad de comenzar a usar SQL Azure Reporting (hasta ahora su uso estaba restringido). En mi caso, tenía ganas de ver de que va esto de SQL Azure Reporting y he de decir que me he quedado un tanto decepcionado ya que:

  • Sólo se pueden crear informes para BD’s SQL Azure, no estando soportados otros orígenes de datos.
  • A la hora de crear un informe de SQL Azure Reporting hay que dar más de una “vuelta” hasta darte cuenta del proceso.
  • Relacionado con lo anterior, que no se pueda lanzar el generador de informes desde el portal de Azure para facilitar la creación del informe.

Dicho esto, vamos a ver un pequeño paso a paso de como crear un informe de SQL Azure Reporting:

  • Nos conectamos al portal de Windows Azure y nos validamos con nuestra suscripción. Pulsamos sobre la opción “Informes” disponible en el menú vertical.
  • Lo primero que tendremos que hacer es crear un servidor de SQL Azure Reporting a través de la opción correspondiente. A continuacón, se muestra la correspondiente ventana de Términos de uso…pulsamos “Siguiente” en la misma.
  • En la nueva ventana del asistente, especificamos la suscripción de Azure a crear y la región de provisionaiento y pulsamos “Siguiente”.
image image image
  • Tras especificar usuario y contraseña para SQL Azure Reporting y pulsar Siguiente, comienza el provisionado del servicio.
  • Cuando el proceso acaba, veremos que tenemos creado un nuevo servidor de SQL Azure Reporting bajo nuestra suscripción que podemos proceder a utilizar.
  • Lo primero que necesitamos es un origen de datos que crearemos con la opción correspondiente en la sección Data Source. En esta ventana especificaremos la cadena de conexión que tiene que ser de la forma:
   1: Server=tcp:<Servidor_SQLAzure>.database.windows.net;Database=Customers;User ID=UsuarioSQLAzure;Password=ContraseñaSQLAzure;Trusted_Connection=False;
  • Fijaros que a la hora de especificar la conexión, podemos indicar que o bien se soliciten las credenciales o que estas estén almacenadas de forma segura a nivel de base de datos. En mi caso, he escogido la primera opción aunque la buena práctica sería la segunda y usando un login de SQL Azure con los permisos mínimos para permitir la visualización del informe.
image image image
  • Probamos que la conexión a nuestro SQL Azure es correcta.
  • Una vez creado el origen de datos, este debería aparecer en el listado de objetos de reporting disponibles en el servidor de SQL Azure.
  • A continuación, el objetivo es crear un informe a partir de ese origen de datos definido…y la clave para crearlo es la url del servidor de informes.
image image image
  • Esa Url es la que tenemos que especificar en las opciones de configuración del generador de informes (aká Report Builder).
  • De esta forma, cuando vayamos a crear un origen de datos podremos seleccionar el ya disponible en SQL Azure Reporting. Tened en cuenta que se os irán pidiendo credenciales de acceso al servidor según vayáis creando los sucesivos elementos que se necesitan en el informe.
  • Una vez que tenemos disponible el origen de datos del informe, podemos crear un conjunto de datos a partir del mismo.
image image image
  • Lo siguiente que haremos es diseñar la consulta del informe, ya sea visualmente o vía T-SQL.
  • Probamos que la consulta está operativa.
  • Y a continuación definimos un informe sencillo sobre la base de ese conjunto de datos.
image image image
  • Para cargar el informe en el servidor de SQL Azure Reporting, simplemente usamos la opción de carga disponible en el portal de Windows Azure.
  • Para visualizar el informe desde el servidor de SQL Azure Reporting, simplemente navegamos a la Url del servidor de informes y hacemos clic sobre el informe en cuestión.
  • Cómo es lógico, y de acuerdo a mi configuración, se nos pedirán las credenciales de ejecución.
image image image
  • Tras especificar dichas credenciales, el informe se muestra sin problemas:

image

Y hasta aquí llega este primer post sobre SQL Azure Reporting.

Publicado 14/10/2011 10:55 por Juan Carlos González Martín | con no comments

SharePoint Online: La primera actualización está al caer y estas son las novedades!

Tal y como podéis leer en este post, parece que en breve tendremos una primera actualización para SharePoint Online con novedades importantes anunciadas durante la pasada SharePoint Conference. Estas novedades son:

  • BCS a través de servicios WCF (Por medio de un conector WCF), que sólo estará disponible para planes tipo E.
  • Invitación a usuarios externos que dispongan de un Windows Live ID, superando se entiende la limitación actual de que sólo funciona la invitación a usuarios con cuentas de Hotmail.
  • Soporte oficial de Windows Phone 7 Mango, en concreto los planes tipo P también podrán utilizar WP 7 para conectarse a sus sitios de SharePoint Online.
  • Papelera de reciclaje de sitios, capacidad que tenemos On-Premise desde el SP1 de SharePoint 2010 que se incorpora a SharePoint Online.
  • Navegadores soportados:
    • Soporte oficial para IE 9.
    • Soporte oficial para Google Chrome.

image

Publicado 14/10/2011 8:33 por Juan Carlos González Martín | 3 comment(s)

SharePoint 2010: Como generar un proxy LINQ To SharePoint con ciertas listas y tipos de contenido!

Cuando usamos la herramienta de línea de comandos SPMetal para generar un proxy de LINQ To SharePoint, normalmente generamos una serie de entidades que representan todas las listas y bibliotecas disponibles en el sitio. Ahora bien, puede ser interesante generar un proxy sólo con aquellas listas y bibliotecas que necesitemos…y esto es posible gracias al parámetro “parameters” de SPMetal que permite especificar en un archivo XML que listas o bibliotecas tiene que incluir el proxy a generar. La sintaxis a usar sería la siguiente:

   1: spmetal /web:http://<mySharePointSite> /namespace:SPLINQSmallProxy /parameters:LINQToSPProxyConfiguration.xml /code::SPLINQSmallProxy.cs

Y el contenido del archivo XML que define como crear el Proxy el siguiente:

   1: <?xml version="1.0" encoding="utf-8"?>
   2: <Web AccessModifier="Internal" xmlns="http://schemas.microsoft.com/SharePoint/2009/spmetal">
   3:     <List Name="Tareas">
   4:         <ContentType Name="Tarea" Class="Tarea" />        
   5:     </List>
   6:     <List Name="Empresas" />
   7:     <ExcludeOtherLists />
   8: </Web>

Como vemos en el archivo de configuración:

  • Estamos incluyendo en el proxy generado la lista Tareas y el tipo de contenido Tarea.
  • Estamos incluyendo la lista Empresa.
  • Estamos excluyendo el resto de listas.

De esta forma, el proxy generado sería el siguiente:

   1: //------------------------------------------------------------------------------
   2: // <auto-generated>
   3: //     This code was generated by a tool.
   4: //     Runtime Version:2.0.50727.4952
   5: //
   6: //     Changes to this file may cause incorrect behavior and will be lost if
   7: //     the code is regenerated.
   8: // </auto-generated>
   9: //------------------------------------------------------------------------------
  10:  
  11: namespace SPLINQSmallProxy {
  12:     using System;
  13:     
  14:     
  15:     internal partial class SPLINQSmallProxySiteDataContext : Microsoft.SharePoint.Linq.DataContext {
  16:         
  17:         #region Extensibility Method Definitions
  18:         partial void OnCreated();
  19:         #endregion
  20:         
  21:         public SPLINQSmallProxySiteDataContext(string requestUrl) : 
  22:                 base(requestUrl) {
  23:             this.OnCreated();
  24:         }
  25:         
  26:         [Microsoft.SharePoint.Linq.ListAttribute(Name="Empresas")]
  27:         public Microsoft.SharePoint.Linq.EntityList<EmpresasItem> Empresas {
  28:             get {
  29:                 return this.GetList<EmpresasItem>("Empresas");
  30:             }
  31:         }
  32:         
  33:         /// <summary>
  34:         /// Utilice la lista de tareas para controlar el trabajo que usted o su grupo tiene que realizar.
  35:         /// </summary>
  36:         [Microsoft.SharePoint.Linq.ListAttribute(Name="Tareas")]
  37:         public Microsoft.SharePoint.Linq.EntityList<Item> Tareas {
  38:             get {
  39:                 return this.GetList<Item>("Tareas");
  40:             }
  41:         }
  42:     }
  43:     
  44:     /// <summary>
  45:     /// Create a new list item.
  46:     /// </summary>
  47:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Item", Id="0x01")]
  48:     [Microsoft.SharePoint.Linq.DerivedEntityClassAttribute(Type=typeof(EmpresasItem))]
  49:     [Microsoft.SharePoint.Linq.DerivedEntityClassAttribute(Type=typeof(Folder))]
  50:     [Microsoft.SharePoint.Linq.DerivedEntityClassAttribute(Type=typeof(Task))]
  51:     internal partial class Item : Microsoft.SharePoint.Linq.ITrackEntityState, Microsoft.SharePoint.Linq.ITrackOriginalValues, System.ComponentModel.INotifyPropertyChanged, System.ComponentModel.INotifyPropertyChanging {
  52:         
  53:         private System.Nullable<int> _id;
  54:         
  55:         private System.Nullable<int> _version;
  56:         
  57:         private string _path;
  58:         
  59:         private Microsoft.SharePoint.Linq.EntityState _entityState;
  60:         
  61:         private System.Collections.Generic.IDictionary<string, object> _originalValues;
  62:         
  63:         private string _title;
  64:         
  65:         #region Extensibility Method Definitions
  66:         partial void OnLoaded();
  67:         partial void OnValidate();
  68:         partial void OnCreated();
  69:         #endregion
  70:  
  71:         Microsoft.SharePoint.Linq.EntityState Microsoft.SharePoint.Linq.ITrackEntityState.EntityState {
  72:             get {
  73:                 return this._entityState;
  74:             }
  75:             set {
  76:                 if ((value != this._entityState)) {
  77:                     this._entityState = value;
  78:                 }
  79:             }
  80:         }
  81:  
  82:         System.Collections.Generic.IDictionary<string, object> Microsoft.SharePoint.Linq.ITrackOriginalValues.OriginalValues {
  83:             get {
  84:                 if ((null == this._originalValues)) {
  85:                     this._originalValues = new System.Collections.Generic.Dictionary<string, object>();
  86:                 }
  87:                 return this._originalValues;
  88:             }
  89:         }
  90:         
  91:         public Item() {
  92:             this.OnCreated();
  93:         }
  94:         
  95:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="ID", Storage="_id", ReadOnly=true, FieldType="Counter")]
  96:         public System.Nullable<int> Id {
  97:             get {
  98:                 return this._id;
  99:             }
 100:             set {
 101:                 if ((value != this._id)) {
 102:                     this.OnPropertyChanging("Id", this._id);
 103:                     this._id = value;
 104:                     this.OnPropertyChanged("Id");
 105:                 }
 106:             }
 107:         }
 108:         
 109:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="owshiddenversion", Storage="_version", ReadOnly=true, FieldType="Integer")]
 110:         public System.Nullable<int> Version {
 111:             get {
 112:                 return this._version;
 113:             }
 114:             set {
 115:                 if ((value != this._version)) {
 116:                     this.OnPropertyChanging("Version", this._version);
 117:                     this._version = value;
 118:                     this.OnPropertyChanged("Version");
 119:                 }
 120:             }
 121:         }
 122:         
 123:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="FileDirRef", Storage="_path", ReadOnly=true, FieldType="Lookup", IsLookupValue=true)]
 124:         public string Path {
 125:             get {
 126:                 return this._path;
 127:             }
 128:             set {
 129:                 if ((value != this._path)) {
 130:                     this.OnPropertyChanging("Path", this._path);
 131:                     this._path = value;
 132:                     this.OnPropertyChanged("Path");
 133:                 }
 134:             }
 135:         }
 136:         
 137:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Title", Storage="_title", Required=true, FieldType="Text")]
 138:         public virtual string Title {
 139:             get {
 140:                 return this._title;
 141:             }
 142:             set {
 143:                 if ((value != this._title)) {
 144:                     this.OnPropertyChanging("Title", this._title);
 145:                     this._title = value;
 146:                     this.OnPropertyChanged("Title");
 147:                 }
 148:             }
 149:         }
 150:         
 151:         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
 152:         
 153:         public event System.ComponentModel.PropertyChangingEventHandler PropertyChanging;
 154:         
 155:         protected virtual void OnPropertyChanged(string propertyName) {
 156:             if ((null != this.PropertyChanged)) {
 157:                 this.PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
 158:             }
 159:         }
 160:         
 161:         protected virtual void OnPropertyChanging(string propertyName, object value) {
 162:             if ((null == this._originalValues)) {
 163:                 this._originalValues = new System.Collections.Generic.Dictionary<string, object>();
 164:             }
 165:             if ((false == this._originalValues.ContainsKey(propertyName))) {
 166:                 this._originalValues.Add(propertyName, value);
 167:             }
 168:             if ((null != this.PropertyChanging)) {
 169:                 this.PropertyChanging(this, new System.ComponentModel.PropertyChangingEventArgs(propertyName));
 170:             }
 171:         }
 172:     }
 173:     
 174:     /// <summary>
 175:     /// Create a new folder.
 176:     /// </summary>
 177:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Folder", Id="0x0120")]
 178:     [Microsoft.SharePoint.Linq.DerivedEntityClassAttribute(Type=typeof(SummaryTask))]
 179:     internal partial class Folder : Item {
 180:         
 181:         private string _name;
 182:         
 183:         private System.Nullable<int> _itemChildCountId;
 184:         
 185:         private string _itemChildCountItemChildCount;
 186:         
 187:         private System.Nullable<int> _folderChildCountId;
 188:         
 189:         private string _folderChildCountFolderChildCount;
 190:         
 191:         #region Extensibility Method Definitions
 192:         partial void OnLoaded();
 193:         partial void OnValidate();
 194:         partial void OnCreated();
 195:         #endregion
 196:         
 197:         public Folder() {
 198:             this.OnCreated();
 199:         }
 200:         
 201:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="FileLeafRef", Storage="_name", Required=true, FieldType="File")]
 202:         public string Name {
 203:             get {
 204:                 return this._name;
 205:             }
 206:             set {
 207:                 if ((value != this._name)) {
 208:                     this.OnPropertyChanging("Name", this._name);
 209:                     this._name = value;
 210:                     this.OnPropertyChanged("Name");
 211:                 }
 212:             }
 213:         }
 214:         
 215:         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 216:         [Microsoft.SharePoint.Linq.RemovedColumnAttribute()]
 217:         public override string Title {
 218:             get {
 219:                 throw new System.InvalidOperationException("Field Title was removed from content type Folder.");
 220:             }
 221:             set {
 222:                 throw new System.InvalidOperationException("Field Title was removed from content type Folder.");
 223:             }
 224:         }
 225:         
 226:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="ItemChildCount", Storage="_itemChildCountId", ReadOnly=true, FieldType="Lookup", IsLookupId=true)]
 227:         public System.Nullable<int> ItemChildCountId {
 228:             get {
 229:                 return this._itemChildCountId;
 230:             }
 231:             set {
 232:                 if ((value != this._itemChildCountId)) {
 233:                     this.OnPropertyChanging("ItemChildCountId", this._itemChildCountId);
 234:                     this._itemChildCountId = value;
 235:                     this.OnPropertyChanged("ItemChildCountId");
 236:                 }
 237:             }
 238:         }
 239:         
 240:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="ItemChildCount", Storage="_itemChildCountItemChildCount", ReadOnly=true, FieldType="Lookup", IsLookupValue=true)]
 241:         public string ItemChildCountItemChildCount {
 242:             get {
 243:                 return this._itemChildCountItemChildCount;
 244:             }
 245:             set {
 246:                 if ((value != this._itemChildCountItemChildCount)) {
 247:                     this.OnPropertyChanging("ItemChildCountItemChildCount", this._itemChildCountItemChildCount);
 248:                     this._itemChildCountItemChildCount = value;
 249:                     this.OnPropertyChanged("ItemChildCountItemChildCount");
 250:                 }
 251:             }
 252:         }
 253:         
 254:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="FolderChildCount", Storage="_folderChildCountId", ReadOnly=true, FieldType="Lookup", IsLookupId=true)]
 255:         public System.Nullable<int> FolderChildCountId {
 256:             get {
 257:                 return this._folderChildCountId;
 258:             }
 259:             set {
 260:                 if ((value != this._folderChildCountId)) {
 261:                     this.OnPropertyChanging("FolderChildCountId", this._folderChildCountId);
 262:                     this._folderChildCountId = value;
 263:                     this.OnPropertyChanged("FolderChildCountId");
 264:                 }
 265:             }
 266:         }
 267:         
 268:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="FolderChildCount", Storage="_folderChildCountFolderChildCount", ReadOnly=true, FieldType="Lookup", IsLookupValue=true)]
 269:         public string FolderChildCountFolderChildCount {
 270:             get {
 271:                 return this._folderChildCountFolderChildCount;
 272:             }
 273:             set {
 274:                 if ((value != this._folderChildCountFolderChildCount)) {
 275:                     this.OnPropertyChanging("FolderChildCountFolderChildCount", this._folderChildCountFolderChildCount);
 276:                     this._folderChildCountFolderChildCount = value;
 277:                     this.OnPropertyChanged("FolderChildCountFolderChildCount");
 278:                 }
 279:             }
 280:         }
 281:     }
 282:     
 283:     /// <summary>
 284:     /// Track a work item that you or your team needs to complete.
 285:     /// </summary>
 286:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Task", Id="0x0108")]
 287:     [Microsoft.SharePoint.Linq.DerivedEntityClassAttribute(Type=typeof(TareasTask))]
 288:     internal partial class Task : Item {
 289:         
 290:         private System.Nullable<double> _complete;
 291:         
 292:         private string _body;
 293:         
 294:         private System.Nullable<System.DateTime> _startDate;
 295:         
 296:         protected System.Nullable<System.DateTime> _dueDate;
 297:         
 298:         private System.Nullable<Priority> _priority;
 299:         
 300:         protected System.Nullable<TaskStatus> _taskStatus;
 301:         
 302:         private System.Nullable<int> _assignedToId;
 303:         
 304:         private string _assignedTo;
 305:         
 306:         #region Extensibility Method Definitions
 307:         partial void OnLoaded();
 308:         partial void OnValidate();
 309:         partial void OnCreated();
 310:         #endregion
 311:         
 312:         public Task() {
 313:             this.OnCreated();
 314:         }
 315:         
 316:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="PercentComplete", Storage="_complete", FieldType="Number")]
 317:         public System.Nullable<double> Complete {
 318:             get {
 319:                 return this._complete;
 320:             }
 321:             set {
 322:                 if ((value != this._complete)) {
 323:                     this.OnPropertyChanging("Complete", this._complete);
 324:                     this._complete = value;
 325:                     this.OnPropertyChanged("Complete");
 326:                 }
 327:             }
 328:         }
 329:         
 330:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Body", Storage="_body", FieldType="Note")]
 331:         public string Body {
 332:             get {
 333:                 return this._body;
 334:             }
 335:             set {
 336:                 if ((value != this._body)) {
 337:                     this.OnPropertyChanging("Body", this._body);
 338:                     this._body = value;
 339:                     this.OnPropertyChanged("Body");
 340:                 }
 341:             }
 342:         }
 343:         
 344:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="StartDate", Storage="_startDate", FieldType="DateTime")]
 345:         public System.Nullable<System.DateTime> StartDate {
 346:             get {
 347:                 return this._startDate;
 348:             }
 349:             set {
 350:                 if ((value != this._startDate)) {
 351:                     this.OnPropertyChanging("StartDate", this._startDate);
 352:                     this._startDate = value;
 353:                     this.OnPropertyChanged("StartDate");
 354:                 }
 355:             }
 356:         }
 357:         
 358:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="TaskDueDate", Storage="_dueDate", FieldType="DateTime")]
 359:         public virtual System.Nullable<System.DateTime> DueDate {
 360:             get {
 361:                 return this._dueDate;
 362:             }
 363:             set {
 364:                 if ((value != this._dueDate)) {
 365:                     this.OnPropertyChanging("DueDate", this._dueDate);
 366:                     this._dueDate = value;
 367:                     this.OnPropertyChanged("DueDate");
 368:                 }
 369:             }
 370:         }
 371:         
 372:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Priority", Storage="_priority", FieldType="Choice")]
 373:         public System.Nullable<Priority> Priority {
 374:             get {
 375:                 return this._priority;
 376:             }
 377:             set {
 378:                 if ((value != this._priority)) {
 379:                     this.OnPropertyChanging("Priority", this._priority);
 380:                     this._priority = value;
 381:                     this.OnPropertyChanged("Priority");
 382:                 }
 383:             }
 384:         }
 385:         
 386:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="TaskStatus", Storage="_taskStatus", FieldType="Choice")]
 387:         public virtual System.Nullable<TaskStatus> TaskStatus {
 388:             get {
 389:                 return this._taskStatus;
 390:             }
 391:             set {
 392:                 if ((value != this._taskStatus)) {
 393:                     this.OnPropertyChanging("TaskStatus", this._taskStatus);
 394:                     this._taskStatus = value;
 395:                     this.OnPropertyChanged("TaskStatus");
 396:                 }
 397:             }
 398:         }
 399:         
 400:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="AssignedTo", Storage="_assignedToId", FieldType="User", IsLookupId=true)]
 401:         public System.Nullable<int> AssignedToId {
 402:             get {
 403:                 return this._assignedToId;
 404:             }
 405:             set {
 406:                 if ((value != this._assignedToId)) {
 407:                     this.OnPropertyChanging("AssignedToId", this._assignedToId);
 408:                     this._assignedToId = value;
 409:                     this.OnPropertyChanged("AssignedToId");
 410:                 }
 411:             }
 412:         }
 413:         
 414:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="AssignedTo", Storage="_assignedTo", ReadOnly=true, FieldType="User", IsLookupValue=true)]
 415:         public string AssignedTo {
 416:             get {
 417:                 return this._assignedTo;
 418:             }
 419:             set {
 420:                 if ((value != this._assignedTo)) {
 421:                     this.OnPropertyChanging("AssignedTo", this._assignedTo);
 422:                     this._assignedTo = value;
 423:                     this.OnPropertyChanged("AssignedTo");
 424:                 }
 425:             }
 426:         }
 427:     }
 428:     
 429:     /// <summary>
 430:     /// Group and describe related tasks that you or your team needs to complete.
 431:     /// </summary>
 432:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Summary Task", Id="0x012004")]
 433:     [Microsoft.SharePoint.Linq.DerivedEntityClassAttribute(Type=typeof(TareasSummaryTask))]
 434:     internal partial class SummaryTask : Folder {
 435:         
 436:         private System.Nullable<double> _complete;
 437:         
 438:         private string _body;
 439:         
 440:         private System.Nullable<System.DateTime> _startDate;
 441:         
 442:         protected System.Nullable<System.DateTime> _dueDate;
 443:         
 444:         private System.Nullable<Priority> _priority;
 445:         
 446:         protected System.Nullable<TaskStatus> _taskStatus;
 447:         
 448:         private System.Nullable<int> _assignedToId;
 449:         
 450:         private string _assignedTo;
 451:         
 452:         #region Extensibility Method Definitions
 453:         partial void OnLoaded();
 454:         partial void OnValidate();
 455:         partial void OnCreated();
 456:         #endregion
 457:         
 458:         public SummaryTask() {
 459:             this.OnCreated();
 460:         }
 461:         
 462:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="PercentComplete", Storage="_complete", FieldType="Number")]
 463:         public System.Nullable<double> Complete {
 464:             get {
 465:                 return this._complete;
 466:             }
 467:             set {
 468:                 if ((value != this._complete)) {
 469:                     this.OnPropertyChanging("Complete", this._complete);
 470:                     this._complete = value;
 471:                     this.OnPropertyChanged("Complete");
 472:                 }
 473:             }
 474:         }
 475:         
 476:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Body", Storage="_body", FieldType="Note")]
 477:         public string Body {
 478:             get {
 479:                 return this._body;
 480:             }
 481:             set {
 482:                 if ((value != this._body)) {
 483:                     this.OnPropertyChanging("Body", this._body);
 484:                     this._body = value;
 485:                     this.OnPropertyChanged("Body");
 486:                 }
 487:             }
 488:         }
 489:         
 490:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="StartDate", Storage="_startDate", FieldType="DateTime")]
 491:         public System.Nullable<System.DateTime> StartDate {
 492:             get {
 493:                 return this._startDate;
 494:             }
 495:             set {
 496:                 if ((value != this._startDate)) {
 497:                     this.OnPropertyChanging("StartDate", this._startDate);
 498:                     this._startDate = value;
 499:                     this.OnPropertyChanged("StartDate");
 500:                 }
 501:             }
 502:         }
 503:         
 504:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="TaskDueDate", Storage="_dueDate", FieldType="DateTime")]
 505:         public virtual System.Nullable<System.DateTime> DueDate {
 506:             get {
 507:                 return this._dueDate;
 508:             }
 509:             set {
 510:                 if ((value != this._dueDate)) {
 511:                     this.OnPropertyChanging("DueDate", this._dueDate);
 512:                     this._dueDate = value;
 513:                     this.OnPropertyChanged("DueDate");
 514:                 }
 515:             }
 516:         }
 517:         
 518:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Priority", Storage="_priority", FieldType="Choice")]
 519:         public System.Nullable<Priority> Priority {
 520:             get {
 521:                 return this._priority;
 522:             }
 523:             set {
 524:                 if ((value != this._priority)) {
 525:                     this.OnPropertyChanging("Priority", this._priority);
 526:                     this._priority = value;
 527:                     this.OnPropertyChanged("Priority");
 528:                 }
 529:             }
 530:         }
 531:         
 532:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="TaskStatus", Storage="_taskStatus", FieldType="Choice")]
 533:         public virtual System.Nullable<TaskStatus> TaskStatus {
 534:             get {
 535:                 return this._taskStatus;
 536:             }
 537:             set {
 538:                 if ((value != this._taskStatus)) {
 539:                     this.OnPropertyChanging("TaskStatus", this._taskStatus);
 540:                     this._taskStatus = value;
 541:                     this.OnPropertyChanged("TaskStatus");
 542:                 }
 543:             }
 544:         }
 545:         
 546:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="AssignedTo", Storage="_assignedToId", FieldType="User", IsLookupId=true)]
 547:         public System.Nullable<int> AssignedToId {
 548:             get {
 549:                 return this._assignedToId;
 550:             }
 551:             set {
 552:                 if ((value != this._assignedToId)) {
 553:                     this.OnPropertyChanging("AssignedToId", this._assignedToId);
 554:                     this._assignedToId = value;
 555:                     this.OnPropertyChanged("AssignedToId");
 556:                 }
 557:             }
 558:         }
 559:         
 560:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="AssignedTo", Storage="_assignedTo", ReadOnly=true, FieldType="User", IsLookupValue=true)]
 561:         public string AssignedTo {
 562:             get {
 563:                 return this._assignedTo;
 564:             }
 565:             set {
 566:                 if ((value != this._assignedTo)) {
 567:                     this.OnPropertyChanging("AssignedTo", this._assignedTo);
 568:                     this._assignedTo = value;
 569:                     this.OnPropertyChanged("AssignedTo");
 570:                 }
 571:             }
 572:         }
 573:     }
 574:     
 575:     /// <summary>
 576:     /// Create a new list item.
 577:     /// </summary>
 578:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Item", Id="0x01", List="Empresas")]
 579:     internal partial class EmpresasItem : Item {
 580:         
 581:         private string _sede;
 582:         
 583:         private System.Nullable<double> _plantilla;
 584:         
 585:         #region Extensibility Method Definitions
 586:         partial void OnLoaded();
 587:         partial void OnValidate();
 588:         partial void OnCreated();
 589:         #endregion
 590:         
 591:         public EmpresasItem() {
 592:             this.OnCreated();
 593:         }
 594:         
 595:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Sede", Storage="_sede", FieldType="Text")]
 596:         public string Sede {
 597:             get {
 598:                 return this._sede;
 599:             }
 600:             set {
 601:                 if ((value != this._sede)) {
 602:                     this.OnPropertyChanging("Sede", this._sede);
 603:                     this._sede = value;
 604:                     this.OnPropertyChanged("Sede");
 605:                 }
 606:             }
 607:         }
 608:         
 609:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Plantilla", Storage="_plantilla", FieldType="Number")]
 610:         public System.Nullable<double> Plantilla {
 611:             get {
 612:                 return this._plantilla;
 613:             }
 614:             set {
 615:                 if ((value != this._plantilla)) {
 616:                     this.OnPropertyChanging("Plantilla", this._plantilla);
 617:                     this._plantilla = value;
 618:                     this.OnPropertyChanged("Plantilla");
 619:                 }
 620:             }
 621:         }
 622:     }
 623:     
 624:     /// <summary>
 625:     /// Track a work item that you or your team needs to complete.
 626:     /// </summary>
 627:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Task", Id="0x0108", List="Tareas")]
 628:     internal partial class TareasTask : Task {
 629:         
 630:         private Microsoft.SharePoint.Linq.EntitySet<Item> _predecessors;
 631:         
 632:         #region Extensibility Method Definitions
 633:         partial void OnLoaded();
 634:         partial void OnValidate();
 635:         partial void OnCreated();
 636:         #endregion
 637:         
 638:         public TareasTask() {
 639:             this._predecessors = new Microsoft.SharePoint.Linq.EntitySet<Item>();
 640:             this._predecessors.OnSync += new System.EventHandler<Microsoft.SharePoint.Linq.AssociationChangedEventArgs<Item>>(this.OnPredecessorsSync);
 641:             this._predecessors.OnChanged += new System.EventHandler(this.OnPredecessorsChanged);
 642:             this._predecessors.OnChanging += new System.EventHandler(this.OnPredecessorsChanging);
 643:             this.OnCreated();
 644:         }
 645:         
 646:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="DueDate", Storage="_dueDate", FieldType="DateTime")]
 647:         public override System.Nullable<System.DateTime> DueDate {
 648:             get {
 649:                 return this._dueDate;
 650:             }
 651:             set {
 652:                 if ((value != this._dueDate)) {
 653:                     this.OnPropertyChanging("DueDate", this._dueDate);
 654:                     this._dueDate = value;
 655:                     this.OnPropertyChanged("DueDate");
 656:                 }
 657:             }
 658:         }
 659:         
 660:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Status", Storage="_taskStatus", FieldType="Choice")]
 661:         public override System.Nullable<TaskStatus> TaskStatus {
 662:             get {
 663:                 return this._taskStatus;
 664:             }
 665:             set {
 666:                 if ((value != this._taskStatus)) {
 667:                     this.OnPropertyChanging("TaskStatus", this._taskStatus);
 668:                     this._taskStatus = value;
 669:                     this.OnPropertyChanged("TaskStatus");
 670:                 }
 671:             }
 672:         }
 673:         
 674:         [Microsoft.SharePoint.Linq.AssociationAttribute(Name="Predecessors", Storage="_predecessors", MultivalueType=Microsoft.SharePoint.Linq.AssociationType.Multi, List="Tareas")]
 675:         public Microsoft.SharePoint.Linq.EntitySet<Item> Predecessors {
 676:             get {
 677:                 return this._predecessors;
 678:             }
 679:             set {
 680:                 this._predecessors.Assign(value);
 681:             }
 682:         }
 683:         
 684:         private void OnPredecessorsChanging(object sender, System.EventArgs e) {
 685:             this.OnPropertyChanging("Predecessors", this._predecessors.Clone());
 686:         }
 687:         
 688:         private void OnPredecessorsChanged(object sender, System.EventArgs e) {
 689:             this.OnPropertyChanged("Predecessors");
 690:         }
 691:         
 692:         private void OnPredecessorsSync(object sender, Microsoft.SharePoint.Linq.AssociationChangedEventArgs<Item> e) {
 693:         }
 694:     }
 695:     
 696:     /// <summary>
 697:     /// Group and describe related tasks that you or your team needs to complete.
 698:     /// </summary>
 699:     [Microsoft.SharePoint.Linq.ContentTypeAttribute(Name="Summary Task", Id="0x012004", List="Tareas")]
 700:     internal partial class TareasSummaryTask : SummaryTask {
 701:         
 702:         private Microsoft.SharePoint.Linq.EntitySet<Item> _predecessors;
 703:         
 704:         #region Extensibility Method Definitions
 705:         partial void OnLoaded();
 706:         partial void OnValidate();
 707:         partial void OnCreated();
 708:         #endregion
 709:         
 710:         public TareasSummaryTask() {
 711:             this._predecessors = new Microsoft.SharePoint.Linq.EntitySet<Item>();
 712:             this._predecessors.OnSync += new System.EventHandler<Microsoft.SharePoint.Linq.AssociationChangedEventArgs<Item>>(this.OnPredecessorsSync);
 713:             this._predecessors.OnChanged += new System.EventHandler(this.OnPredecessorsChanged);
 714:             this._predecessors.OnChanging += new System.EventHandler(this.OnPredecessorsChanging);
 715:             this.OnCreated();
 716:         }
 717:         
 718:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="DueDate", Storage="_dueDate", FieldType="DateTime")]
 719:         public override System.Nullable<System.DateTime> DueDate {
 720:             get {
 721:                 return this._dueDate;
 722:             }
 723:             set {
 724:                 if ((value != this._dueDate)) {
 725:                     this.OnPropertyChanging("DueDate", this._dueDate);
 726:                     this._dueDate = value;
 727:                     this.OnPropertyChanged("DueDate");
 728:                 }
 729:             }
 730:         }
 731:         
 732:         [Microsoft.SharePoint.Linq.ColumnAttribute(Name="Status", Storage="_taskStatus", FieldType="Choice")]
 733:         public override System.Nullable<TaskStatus> TaskStatus {
 734:             get {
 735:                 return this._taskStatus;
 736:             }
 737:             set {
 738:                 if ((value != this._taskStatus)) {
 739:                     this.OnPropertyChanging("TaskStatus", this._taskStatus);
 740:                     this._taskStatus = value;
 741:                     this.OnPropertyChanged("TaskStatus");
 742:                 }
 743:             }
 744:         }
 745:         
 746:         [Microsoft.SharePoint.Linq.AssociationAttribute(Name="Predecessors", Storage="_predecessors", MultivalueType=Microsoft.SharePoint.Linq.AssociationType.Multi, List="Tareas")]
 747:         public Microsoft.SharePoint.Linq.EntitySet<Item> Predecessors {
 748:             get {
 749:                 return this._predecessors;
 750:             }
 751:             set {
 752:                 this._predecessors.Assign(value);
 753:             }
 754:         }
 755:         
 756:         private void OnPredecessorsChanging(object sender, System.EventArgs e) {
 757:             this.OnPropertyChanging("Predecessors", this._predecessors.Clone());
 758:         }
 759:         
 760:         private void OnPredecessorsChanged(object sender, System.EventArgs e) {
 761:             this.OnPropertyChanged("Predecessors");
 762:         }
 763:         
 764:         private void OnPredecessorsSync(object sender, Microsoft.SharePoint.Linq.AssociationChangedEventArgs<Item> e) {
 765:         }
 766:     }
 767:     
 768:     internal enum Priority : int {
 769:         
 770:         None = 0,
 771:         
 772:         Invalid = 1,
 773:         
 774:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="(1) Alta")]
 775:         _1Alta = 2,
 776:         
 777:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="(2) Normal")]
 778:         _2Normal = 4,
 779:         
 780:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="(3) Baja")]
 781:         _3Baja = 8,
 782:     }
 783:     
 784:     internal enum TaskStatus : int {
 785:         
 786:         None = 0,
 787:         
 788:         Invalid = 1,
 789:         
 790:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="No iniciada")]
 791:         NoIniciada = 2,
 792:         
 793:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="En curso")]
 794:         EnCurso = 4,
 795:         
 796:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="Completada")]
 797:         Completada = 8,
 798:         
 799:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="Aplazada")]
 800:         Aplazada = 16,
 801:         
 802:         [Microsoft.SharePoint.Linq.ChoiceAttribute(Value="A la espera de otra persona")]
 803:         ALaEsperaDeOtraPersona = 32,
 804:     }
 805: }

Cómo vemos sólo contiene entidades relativas  a las listas Tareas y Empresas. Si representamos el correspondiente diagrama de clases, este hecho quedará mucho más claro.

image

Publicado 13/10/2011 17:57 por Juan Carlos González Martín | 3 comment(s)

SharePoint 2010: Como crear un Timer Job con las Tools de VS 2010 para SharePoint (II)!

Como sabéis, en SharePoint cuando estamos hablando de realizar una tarea o trabajo de acuerdo a una cierta programación estamos pensando en Timer Jobs. Un Timer Job en el fondo no deja de ser un proceso que se ejecuta de acuerdo a una cierta periodicidad (minutos, horas o días) y se puede crear con ayuda de las Visual Studio 2010 Tools para SharePoint o de manera más sencilla con una extensión personalizada que nos cree toda la base necesaria para desarrollar nuestros Timer Jobs como por ejemplo esta extensión creada por Scott Hillier:

  • Como siempre, iniciamos VS 2010 y creamos un proyecto de SharePoint de tipo vacío.
  • Como vamos a crear un Timer Job, elegimos como tipo de despliegue de la solución el de “Farm solution”.
  • Una vez creado el proyecto, le añadimos un elemento de Timer Job.
image image image
  • A continuación se muestra un diálogo en el que especificamos el nombre del Timer Job.
  • Una vez pulsado OK, se añaden todos los elementos necesarios para tener un primer Timer Job Operativo incluyendo una página de administración para el mismo.
  • Por supuesto, se añade la correspondiente característica cuyo ámbito es Aplicación web.
image image image

Publicado 12/10/2011 16:23 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: ¿Es una plataforma transaccional?

Un tema de debate continuo cuando se habla de diseñar e implementar soluciones sobre SharePoint es el relativo a la transaccionalidad en la manipulación de los datos que es una necesidad común en cualquier sistema transaccional…y es aquí dónde encontramos la clave en lo que a SharePoint se refiere ya que no es un sistema transaccional y presenta la particularidad de que toda manipulación de información se realiza a través del modelo de objetos. De hecho, y como tantas veces se habrá dicho, aunque SharePoint se apoye en SQL Server, no se trata de un sistema de gestión de base  de datos (DBMS). Implica esto que no podarnos conseguir este componente de transaccionalidad que se pueda necesitas…pues lógicamente no, lo que implica es que lo tendremos que implementar nosotros mismos a través de un sistema de compensación personalizado o algo por el estilo:

  • Por ejemplo, se podría usar Windows Workfow Foundaton (WF) y la actividad CompensatableSequence para ello.
  • En cualquier caso, vamos a tener que hacer un seguimiento de como la información cambia en las bases de datos de contenidos para poder revertirla al estado original en el caso de que ocurra un error. Por ejemplo, si estamos actualizando elementos de una lista mediante SPListItem y el método Update() tendremos que hacer ese seguimiento y registrar la información para permitir una hipotética vuelta a atrás en caso de error.
  • Lo mismo sucede si estamos actualizando información en SharePoint y en sistemas externos. Si el proceso de actualización en el sistema externo falla, no tenemos por defecto la posibilidad de volver a restaurar la información original en SharePoint salvo que implementemos la funcionalidad nosotros mismos.

En resumen, si la transaccionalidad es un requisito vital para la solución que queramos diseñar e implementar sobre SharePoint nos deberíamos replantear si SharePoint es la plataforma adecuada o no.

SharePoint2010_thumb

Publicado 11/10/2011 12:22 por Juan Carlos González Martín | 1 comment(s)

SharePoint Online: Limitaciones por área de funcionalidad!

Al igual que ocurre con SharePoint On-Premise, su homólogo en la nube dispone de una serie de capacidades englobadas en una serie de áreas funcionales que se representan en la imagen tan característica que todos conocemos:

SharePoint2010_thumb

Ahora bien, en SharePoint Online tenemos un subconjunto de funcionalidades de SharePoint On-Premise que en la práctica da lugar a una serie de limitaciones por área de funcionalidad:

  • Sitios, SharePoint Online permite modelar escenarios Intranet igual que su homólogo On-Premise. Sin embargo, a diferencia de este no tendremos la posibilidad de integrar datos de negocio debido a que de momento no contamos con los Business Connectivity Services. En el caso de escenarios Internet, SharePoint Online si que presenta características muy limitadas comparadas con el caso On-Premise. Así, no dispondremos de las características de publicación de SharePoint 2010 para sitios de SharePoint 2010, en su lugar podremos crear sitios web sencillos pensados para dotar de presencia en Internet a pequeñas y medianas empresas, pero resultando muy limitados para grandes organizaciones.
  • Comunidades, en SharePoint Online podemos crear sitios personales de usuario. Ahora bien, tendremos los siguientes limitantes:
    • El tamaño máximo permitido para un sitio personal es de 500 MB.
    • No se puede cambiar la plantilla del sitio raíz de la colección de sitios del sitio personal.
    • No se pueden añadir nuevas propiedades personalizadas a los perfiles de usuario que puedan contener información procedente de otros sistemas de la empresa como aplicaciones de RRHH.
    • No se soportan soluciones personalizadas para los sitios personales.
  • Contenidos, casi todas las capacidades de ECM de SharePoint 2010 están disponibles en SharePoint Online. Ahora bien, por cuestiones principalmente de rendimiento y capacidad nos encontraremos con las siguientes limitaciones:
    • El límite de tamaño para una colección de sitios es de 100 GB, y el máximo número de colecciones de sitios por tenant es de 300, siendo el espacio máximo de almacenamiento de 5 TB.
    • No se dispone de la funcionalidad de Records Center.
    • No se soportan bibliotecas de documentos que puedan recibir correo electrónico, lo que impacta en aquellos escenarios en los que se quieran integrar funcionalidades de escaneo y fax integrado con SharePoint Online.
    • No se pueden abrir, por defecto, documentos PDF en el navegador aunque esta limitación se puede superar con algún pequeño workaround siempre a nivel de biblioteca.
    • Las características de Word Automation no están disponibles.
    • El sistema de auditorías no captura información relativa a que documentos están abiertos y cerrados.
  • Búsquedas, se soporta búsquedas de información entre todas las colecciones de sitios (incluyendo los sitios personales) de un cierto tenant. Sin embargo están presentes limitaciones como:
    • No se soporta la integración de búsquedas On-Premise con búsquedas online.
    • No se soporta indexar contenido de otras fuentes diferentes. Las configuraciones permitidas para la búsqueda en SharePoint Online son muy limitadas.
    • No se soporta búsqueda FAST.
    • El crawling de contenidos se realiza cada hora para refrescar los índices.
    • No se soportan iFilters personalizados. El único externo soportado de momento es el de PDF.
    • No se soporta la indexación de múltiples orígenes de contenidos.
    • No se soportan búsquedas federadas.
    • Integración de la búsqueda con Windows 7.
  • Perspectivas, en este caso se cuentan con las siguientes limitaciones:
    • No tenemos disponible la plantilla Business Intelligence Center.
    • No se soporta PowerPivot, PerformancePoint y la integración con Reporting Services.
  • Aplicaciones Compuestas, en este caso no se soporta lo siguiente:
    • Integración de sistemas de negocio.
    • Sistemas de Workflow o de BPM avanzados como los ofrecidos por K2, Nintex o AgilePoint.
    • Código Full-Trust.

Y hasta aquí llega este posts sobre limitaciones por área de funcionalidad en SharePoint Online en Office 365.

Publicado 10/10/2011 22:30 por Juan Carlos González Martín | 2 comment(s)

Office 365: Como añadir el botón “Me gusta” de Facebook en nuestro sitio público!

Preguntaban el otro día en los foros de Office 365 sobre como añadir el botón “Me Gusta” de Facebook en un sitio público de Office 365, y un colaborador comentó su solución, por lo que me decidí a crear un sencillo paso a paso sobre como añadir esta opción a una página de nuestro sitio:

  • En primer lugar, necesitamos acceder a nuestro sitio y validarnos a través de la opción “Iniciar sesión de miembro”.
  • De esta forma, se muestra la biblioteca de páginas web que forman parte de nuestro sitio público y que podremos personalizar. Hacemos clic sobre una de dichas páginas.
  • A continuación se muestra dicha página en tiempo de diseño. Seleccionaos la zona de la página donde queremos añadir el “Me Gusta” y pulsamos sobre “Insertar –> HTML”.
image image image
  • En la ventana que se abre simplemente insertamos el código HTML que nos permite añadir la opción “Me Gusta” de Facebook para una página en concreto usando en este caso un iFrame.
   1: <html>
   2: <head>
   3: <title>Me gusta El Marca</title>
   4: </head>
   5: <body>
   6: <iframe src="http://www.facebook.com/plugins/like.php?href=http://www.facebook.com/MARCA" scrolling="no" frameborder="0" style="border:none; width:450px; height:80px"></iframe>
   7: </body>
   8: </html>
  • Pulsamos “Aceptar” en la ventana HTML de manera que en el diseñador podemos ver que ya se muestra la opción “Me Gusta” de la página.
  • Guardamos y publicamos los cambios. Comprobamos que tenemos la opción disponible y operativa en la página publicada.
image image image

Referencia: http://community.office365.com/es-es/f/197/t/11405.aspx

Publicado 9/10/2011 9:01 por Juan Carlos González Martín | 3 comment(s)

SharePoint 2010: ¿Se pueden añadir acciones personalizadas en formularios InfoPath?

El otro día planteaban en los foros de desarrollo de SharePoint una cuestión relativa a si es posible extender o no la cinta de un formulario InfoPath renderizado en el navegador de la misma forma que podemos extender la cinta de SharePoint 2010 a distintos niveles…por suerte, la respuesta es que sí y pasa por crear una acción personalizada modelada en el correspondiente archivo definición en el que incluiremos la ubicación de la acción y el comando a ejecutar. Podéis encontrar un ejemplo de acción personalizada para formularios InfoPath en este enlace.

SharePoint2010_thumb

Publicado 8/10/2011 10:54 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Utilidades para FBA en Codeplex!

Como sabéis, en SharePoint 2010 como ocurría con su predecesor es posible utilizar diferentes mecanismos de autenticación y uno de los más usados fuera de la autenticación NTLM de toda la vida es la autenticación basada en formularios con usuarios que pueden estar en una base de datos o en otro repositorio. En este sentido, una necesidad recurrente cuando se quiere utilizar FBA en despliegues de SharePoint es la de disponer de un conjunto de utilidades que permita realizar tareas comunes en la gestión de usuarios como pueden ser altas, modificaciones, borrados, cambios de contraseña, etc…y todo ello integrado en SharePoint. Para disponer de estas utilidades tendremos siempre dos opciones:

  • Yo me lo guiso y yo me lo como cual Juan Palomo, es decir, nosotros mismos nos creamos esos componentes desde cero.
  • O bien partimos de componentes y utilidades ya realizadas disponibles en Codeplex y de las que normalmente tendremos su código fuente…cuando digo partimos es que podemos apoyarnos en ese código fuente para no tener que reinventar la rueda.

Con respecto al segundo punto, revisando Codeplex he encontrado varios proyectos interesantes en torno a FBA en SharePoint…el que más me ha llamado la atención es el de Ventigrate.

MembershipRequestWebPart

Publicado 7/10/2011 21:01 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Apertura de ventanas modales y páginas desde acciones personalizadas (I)!

Hace bastante tiempo hablaba sobre como podemos crear acciones personalizadas para la Ribbon de una lista, de un formulario de lista o bien el menú contextual de elemento utilizando SharePoint Designer 2010 (SPD 2010) para ello. En este post vamos a ir un paso más allá y ver como mediante esas acciones personalizadas podemos incluso aprovecharnos del framework e ventanas modales de SharePoint 2010:

  • En SharePoint Designer 2010, nos vamos a la sección Listas y Bibliotecas (Lists and Libraries) y pulsamos sobre una de las listas disponibles. Por ejemplo, pulsamos sobre la lista por defecto de tipo “Anuncios”.
  • En la Ribbon de la página de resumen de la lista pulsamos sobre “Custom Action -> List Item Menu”.
  • En la ventana que se abre, especificamos los parámetros relativos a la acción personalizada:
    • Nombre: “Ayuda”.
    • Descripción: “Mostrar la ayuda de la lista”..
    • Como tipo de acción, elegimos “Naviage to Url” y es aquí dónde viene la clave para la apertura de una ventana modal ya que especificaremos lo siguiente:
   1: BLOCKED SCRIPTSP.UI.ModalDialog.showModalDialog({url:"/_layouts/help.aspx", title: "Ayuda" }); return false;
  •  
    • Si quisiéramos hacer lo mismo para una acción de la Ribbon de lista, el código JavaScript cambia ligeramente:
   1: BLOCKED SCRIPTSP.UI.ModalDialog.showModalDialog({url:'/_layouts/help.aspx',dialogReturnValueCallback: function(dialogResult, returnValue) { SP.UI.ModalDialog.RefreshPage(SP.UI.DialogResult.OK) }})

 

image image image
  •  
    • Especificamos la Url de la imagen asociada a la acción, un número de secuencia y una máscara de permisos si es necesario.
  • Pulsamos OK para guardar las configuraciones. Comprobamos que la acción se ha añadido en la correspondiente sección de acciones.
  • Comprobamos que la acción se muestra en el menú contextual del elemento.
image image image
  • Comprobamos que la acción que funciona como se espera:

image

Fuente: http://blog.lekman.com/2010/08/custom-sharepoint-context-action-links.html

Publicado 6/10/2011 22:11 por Juan Carlos González Martín | 6 comment(s)

SharePoint y SSRS: Resumen de posts sobre la integración entre ambos!

Muchos artículos se han escrito respecto a la integración de SharePoint y SSRS en el blog del CIIN, por lo que de cara a facilitar su localización he decidido crear un artículo que los recoja:

Integración de SharePoint 2010 y SSRS Denali

Integración de SharePoint 2010 y SSRS (2008 y 2008 R2)

Integración de SharePoint 2007 y SSRS (2005 y 2008)

Publicado 6/10/2011 2:50 por Juan Carlos González Martín | 2 comment(s)

SharePoint 2010: Como solucionar el problema “The report server cannot decrypt the symmetric key that is used to access sensitive or encrypted data in a report server database”!

Pues con este “chorizo” de error me encontré el otro día cuando iba a hacer unas pruebas sobre la integración de SQL Server Reporting Services (SSRS) con SharePoint. De hecho, el error mostrado sólo es una pequeña parte del mostrado en SharePoint:

  • Básicamente, el problema con el qué me encontré es que no podía crear nuevos informes en el Report Builder 3.0 por alguna extraña razón relacionada con el título del artículo por lo que me fui a la Administración Central de SharePoint 2010 para revisar la configuración.
  • Lógicamente, allí también me encontré el correspondiente petardazo que no tenía ni idea que solucionar, pero que gracias a Goog…digo Bing, averigüé rápidamente como se solucionaba.
  • La solución pasa por eliminar las claves de encriptación que usa SSRS y generar unas nuevas usando para ello el Reporting Services Configuration Manager.
image image image
  • De esta forma, SSRS volvió a estar operativo y lo mismo sucedió con la integración con SharePoint.
image image

Publicado 5/10/2011 17:17 por Juan Carlos González Martín | 1 comment(s)

SharePoint Online: El soporte para BCS llegará a finales de año de la mano de servicios de Azure!

Aunque parecía difícil que en la SharePoint Conference de este año se anunciasen muchas novedades, finalmente si que estamos teniendo algunas de la mano de Office 365 y SharePoint Online en concreto. A finales de año, dentro del plan de actualizaciones contemplado en Office 365, se añadirá soporte de BCS (Business Connectivity Services) a SharePoint Online para permitir la integración de datos de negocio vía servicios de Windows Azure. Sin duda, una excelente noticia. Podéis leer más información al respecto en:

image

Publicado 4/10/2011 8:56 por Juan Carlos González Martín | 2 comment(s)

SharePoint 2010: Por qué sigue y seguirá siendo el producto estrella de Microsoft!

Estos días está teniendo lugar en EE.UU (en concreto en Anaheim, California) una nueva edición de la SharePoint Conference centrada en SharePoint 2010 (este no es el año de mostrar algo de SharePoint vNext, habrá que esperar al año que viene a Las Vegas) y proporcionando una excelente oportunidad para hacer networking, y reforzar aún más la idea de que SharePoint es la plataforma que ofrece mejores prestaciones para colaboración, comunicación, productividad, etc. Y como muestra, aparte de que SharePoint es sin duda, el producto estrella de Microsoft, aquí van algunos datos que se han comentado en la Keynote de hoy:

  • En 2008 SharePoint pasó la cifra de 1 billón de $ en ganancias, convirtiéndose en el primer producto en alcanzar este hito de forma tan rápida. Hoy en día su velocidad de crecimiento continua siendo de acuerdo a un ritmo de 2 dígitos.
  • Más de 125 millones de personas y 66.000 organizaciones trabajan con SharePoint.
  • Se han vendido más de 62 millones de licencias de SharePoint 2010.
  • SharePoint es cada vez más la primera elección como herramienta de colaboración principal para compartir información fuera y dentro de las organizaciones.
  • El ecosistema de SharePoint es muy dinámico como demuestra:
    • Los más de 700.000 desarrollares de SharePoint a nivel mundial.
    • Las más de 1.000 soluciones de ISVs construidas sobre SharePoint 2010 y otras 1.000 en desarrollo.
    • En lo que va de año se han entrenado a más de 93.000 partners en plataforma SharePoint.

Está claro que SharePoint mola y se está convirtiendo en la plataforma base y central de muchos productos de Microsoft: el propio SharePoint, Project Server, Office 365, etc. Alguno dirá que SharePoint es la plataforma única de poder, una plataforma para dominarlas a todas…y no andará desencaminado.

SharePoint2010_thumb

Fuentes:

Publicado 3/10/2011 21:26 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Autenticación por formularios contra un LDAP en SharePoint Foundation!

El otro día nos planteaban una cuestión relativa a si es posible configurar SharePoint Foundation para usar autenticación basada en formularios contra un directorio LDAP teniendo en cuenta que:

Evidentemente, tras decir unas cuantas cosas “amables” sobre SharePoint y sobre todo sobre la documentación disponibles (que a veces es incorrecta) nos pusimos a ver como podíamos encontrar solución y apareció por suerte un workaround que en este caso descubrieron mis compañeros Ángel Acha y Pablo Sousa: Su directorio LDAP al que se quiere acceder es un directorio activo, se puede utilizar el proveedor Active Directory Membership Provider, que accede al directorio activo mediante LDAP y que te viene incluido en la librería System.Web. Podéis encontrar información en esta línea en este artículo.

SharePoint2010_thumb

Publicado 2/10/2011 20:34 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Resumen de posts (XXIII)!

Como siempre , después del recopilatorio de enlaces interesantes sobre SharePoint 2010 os dejo el resumen de posts sobre la plataforma que se han publicado en el blog desde principios del mes de septiembre.

Capacidades

Desarrollo

IT

Recursos

Y hasta aquí llega este nueva entrega del resumen de los posts publicados en el blog del CIIN sobre plataforma SharePoint.

Publicado 1/10/2011 9:14 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Recopilatorio de enlaces interesantes (XXIV)!

Como siempre, y para comenzar el mes, aquí os dejo un nuevo recopilatorio de enlaces y recursos interesantes en torno a la plataforma SharePoint 2010. Espero que los encontréis de interés.

Capacidades

Desarrollo

IT

Recursos

Publicado 1/10/2011 9:11 por Juan Carlos González Martín | con no comments

Más artículos < Página anterior