Opções de armazenamento de dados no SharePoint Online
Este artigo descreve o aplicativo de exemplo Core.DataStorageModels, que mostra cada uma das seguintes opções de armazenamento de dados e as vantagens e desvantagens de cada uma:
- Lista do SharePoint na Web do suplemento
- Lista do SharePoint no host da Web
- Serviço Web externo
- Armazenamento de Tabelas do Azure
- Armazenamento de Fila do Azure
- Banco de Dados SQL Azure
O aplicativo de exemplo Core.DataStorageModels é um suplemento hospedado pelo provedor escrito em JavaScript que implanta vários artefatos do SharePoint (listas, parte do suplemento, Web Part) no host da Web e no site do C# suplemento. Ele interage com listas do SharePoint na Web do suplemento e no host da Web e também faz chamadas para o Banco de Dados SQL do Azure, o Armazenamento de Filas do Azure e o Armazenamento de Tabelas do Azure e um serviço Web remoto que implementa o OData. Este exemplo usa o padrão Model-View-Controller.
O aplicativo de exemplo Core.DataStorageModels aplica cada opção de armazenamento de dados a uma função específica para a qual a opção é adequada, conforme descrito na tabela a seguir.
| Opção de armazenamento de aplicativo de exemplo | Usado para |
|---|---|
| Web do suplemento de lista do SharePoint | Notas do cliente |
| Listar a Web do host do SharePoint | Casos de suporte |
| Serviço Web OData da Northwind | Clientes |
| Armazenamento de Tabelas do Azure | Classificações de CSR |
| Armazenamento de Fila do Azure | Fila de chamadas |
| SQL do Azure banco de dados Northwind | Pedidos, detalhes do pedido, produtos |
O aplicativo de exemplo implementa um painel de atendimento ao cliente e interfaces relacionadas que mostram pedidos recentes, classificações de pesquisa representativas do cliente, anotações do cliente, casos de suporte e uma fila de chamadas representativas do cliente.
Os dois primeiros cenários permitem recuperar dados usando código de modelo de objeto de cliente relativamente simples ou consultas REST, mas são limitados por limites de consulta de lista. Os próximos quatro cenários usam diferentes tipos de armazenamento remoto.
Página inicial dos modelos de armazenamento de dados solicitando a implantação de componentes do SharePoint
Antes de você começar
Antes de usar este exemplo, verifique se você tem o seguinte:
Uma Microsoft Azure em que você pode implantar um Banco de Dados SQL do Azure e criar uma conta de Armazenamento do Azure.
Um site de desenvolvedor do SharePoint para que você possa implantar o exemplo de Visual Studio.
Além disso, você precisa implantar o banco de dados Northwind Microsoft Azure.
Para implantar o banco de dados Northwind
Entre no portal do Azure e escolha Servidores de> bancos de dados SQL.
Escolha Criar um servidor de Banco de Dados SQL.
No formulário Criar Servidor, insira valores para nome de logon, senha de logone região.
Marque a caixa de seleção para concluir e criar o servidor.
Agora que você criou o banco de dados, escolha o nome do servidor que você criou.
Escolha CONFIGURAR, escolha a seta no canto inferior direito para concluir a configuração e escolha SALVAR.
Abra SQL Server Management Studio no computador de desenvolvimento local e crie um novo banco de dados chamado NorthWind.
No Pesquisador de Objetos, selecione o banco de dados Northwind e escolha nova consulta.
Em um editor de texto de sua escolha, abra o script SQL northwind.sql fornecido com o exemplo Core.DataStorageModels .
Copie o texto no arquivo northwind.sql e cole-o na janela consulta SQL do SQL Server Management Studio e escolha Executar.
No Pesquisador de Objetos, abra o menu de atalho do banco de dados Northwind, selecione Tarefas e, em seguida, selecione Implantar Banco de Dados no SQL Azure.
Na tela Introdução, escolha Próximo.
Escolha Connecte insira o nome do Server para o servidor Banco de Dados SQL do Azure que você acabou de criar.
Na lista autenticação, selecione SQL Server autenticação.
Insira o nome de usuário e a senha que você usou ao criar o servidor Banco de Dados SQL do Azure e escolha Connect.
Escolha Próximoe, em seguida, Concluire aguarde até que o banco de dados seja criado. Depois de criado, escolha Fechar para fechar o assistente.
Retorne ao portal do Azure para verificar se o banco de dados Northwind foi criado com êxito. Você deve vê-lo listado na bancos de dados SQL tela.
Selecione o banco de dados Northwind e, em seguida, selecione cadeias de conexão do Banco de Dados SQL.
Copie a cadeia de conexão, cole-a em um arquivo de texto e salve-a localmente. Você precisará dessa cadeia de conexão mais tarde. Feche a caixa de diálogo Cadeias Conexão.
Escolha o link Configurar regras de firewall do Windows Azure para esse endereço IP e adicione seu endereço IP às regras de firewall para permitir que você acesse o banco de dados.
Abra o projeto Core.DataStorageModels.sln no Visual Studio.
No Visual Studio Gerenciador de Soluções, localize o arquivo Web.config.
No arquivo Web.config, localize o elemento add
name="NorthWindEntities"e substitua o valor deconnectionStringexistente com as informações de cadeia de conexão salvas localmente na etapa 19.<add name="NorthWindEntities" connectionString="metadata=res://*/Northwind.csdl|res://*/Northwind.ssdl|res://*/Northwind.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=<Your Server Here>.database.windows.net;initial catalog=NorthWind;user id=<Your Username Here>@<Your Server Here>;password=<Your Password Here>;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />
Salve o arquivo Web.config.
Lista do SharePoint na Web do suplemento (cenário de observações)
O cenário De anotações, que usa uma lista do SharePoint em um site de suplemento, mostra como as listas são executadas em um Site de Suplementos do SharePoint. A lista Anotações é criada na Web do suplemento com um campo de título e descrição. A API REST do SharePoint consulta a lista de Anotações e retorna todas as anotações com base em uma ID do cliente.
O uso de listas na Web do suplemento tem uma vantagem importante em relação a outras soluções de armazenamento: você pode usar chamadas simples à API REST do SharePoint para consultar dados.
No entanto, há algumas desvantagens:
- Para atualizar os metadados da lista, você deve atualizar e reimplantar o suplemento.
- Para atualizar a estrutura de dados, você deve reescrever a lógica do aplicativo para armazenar e atualizar dados.
- As informações armazenadas na lista não podem ser compartilhadas facilmente com outros suplementos.
- Não é possível pesquisar dados no SharePoint.
- A quantidade de dados que você pode armazenar em listas e o tamanho dos conjuntos de resultados de consulta são limitados.
O código subjacente à seção Observações do painel do cliente usa consultas REST para recuperar dados de uma lista implantada na Web do suplemento. Esta lista contém campos para títulos, autores, IDs do cliente e descrições. Você pode usar a interface do suplemento para adicionar e recuperar anotações para um cliente especificado, conforme mostrado na figura a seguir.
Interface do usuário para o suplemento Anotações
O Exibir Lista de Anotações no App Web fornece uma exibição completa dos dados da lista.
Esse suplemento usa o padrão Model-View-Controller. Você pode ver o código para o cenário De anotações no arquivo Views/CustomerDashboard/Notes.cshtml. Ele usa chamadas REST simples para adicionar e recuperar dados.
O código a seguir recupera anotações da lista de Anotações de um cliente especificado.
function getNotesAndShow() {
var executor = new SP.RequestExecutor(appWebUrl);
executor.executeAsync(
{
url: appWebUrl + "/_api/web/lists/getByTitle('Notes')/items/" +
"?$select=FTCAM_Description,Modified,Title,Author/ID,Author/Title" +
"&$expand=Author/ID,Author/Title" +
"&$filter=(Title eq '" + customerID + "')",
type: "GET",
dataType: 'json',
headers: { "accept": "application/json;odata=verbose" },
success: function (data) {
var value = JSON.parse(data.body);
showNotes(value.d.results);
},
error: function (error) { console.log(JSON.stringify(error)) }
}
);
}
O código a seguir adiciona uma observação para um determinado cliente à lista de Anotações.
function addNoteToList(note, customerID) {
var executor = new SP.RequestExecutor(appWebUrl);
var bodyProps = {
'__metadata': { 'type': 'SP.Data.NotesListItem' },
'Title': customerID,
'FTCAM_Description': note
};
executor.executeAsync({
url: appWebUrl + "/_api/SP.AppContextSite(@target)/web/lists/getbytitle('Notes')/items?@target='" + appWebUrl + "'",
contentType: "application/json;odata=verbose",
method: "POST",
headers: {
"accept": "application/json;odata=verbose",
"content-type": "application/json;odata=verbose",
"X-RequestDigest": $("#__REQUESTDIGEST").val()
},
body: JSON.stringify(bodyProps),
success: getNotesAndShow,
error: addNoteFailed
});
}
Você pode adicionar 5.000 itens à lista para mostrar que as consultas de lista que geram um conjunto de resultados de 5.000 ou mais itens atingem o limite de consulta de lista e falham. Você também pode adicionar tantos dados à sua lista na Web do suplemento que excedeu o limite de armazenamento para seu conjunto de sites (que depende de quanto espaço de armazenamento você alocou a ele).
Esses cenários mostram duas das limitações mais importantes dessa abordagem: listar limites de tamanho de consulta e limites de espaço de armazenamento. Se a sua empresa precisar que você trabalhe com grandes conjuntos de dados e conjuntos de resultados de consulta, essa abordagem não funcionará.
Limite de consulta de lista
Para carregar dados suficientes para exceder o limite de consulta de lista:
No menu à esquerda, escolha home page de exemplo.
Na seção listar limites de consulta, escolha Adicionar itens de lista à lista Anotações no suplemento da Web.
De acordo com as instruções que aparecem acima do botão, execute esta operação 10 vezes.
Quando a lista De anotações é atualizada, uma mensagem é exibida na parte superior da página que indica quantos itens de lista (Anotações) você adicionou e quantos são restantes para adicionar.
Observação
A operação leva cerca de um minuto para ser executada sempre que você escolher o botão. O resultado final da execução da operação 10 vezes é mostrado na próxima figura.
Depois de adicionar 5.001 itens à lista, escolha Anotações no menu à esquerda. Quando a página é carregada, você vê a mensagem de erro mostrada na figura a seguir, que vem da API REST do SharePoint.
Escolha Exibir Lista de Anotações no App Web página na lista para ver se ela inclui 500 linhas. Observe que, embora os modos de exibição de lista do SharePoint possam acomodar a navegação dessas muitas entradas, a API REST falha devido ao limite de limitação da consulta de lista.
Limite de armazenamento de dados
Para carregar dados suficientes para exceder o limite de armazenamento de dados:
No menu à esquerda, escolha home page de exemplo.
Na seção Limite de Dados, escolha Preencher a lista de Notas web do aplicativo com 1 GB de dados.
De acordo com as instruções que aparecem acima do botão Preencher a lista de Notas web do aplicativo com 1 GB de dados, execute essa operação 11 vezes.
Quando a lista De anotações é atualizada, uma mensagem é exibida na parte superior da página que indica quantos itens de lista (Anotações) você adicionou e quantos são restantes para adicionar.
Observação
A operação leva cerca de um minuto para ser executada sempre que você escolher o botão. O resultado final da execução da operação 11 vezes é mostrado na próxima figura.
Depois de executar a operação 11 vezes, uma mensagem de erro ocorre quando você escolhe o botão, conforme mostrado na figura a seguir.
Depois de exceder o limite de armazenamento de dados, escolha o botão Voltar no navegador da Web e, em seguida, escolha o link Anotações no menu à esquerda.
Escolha Exibir Lista de Anotações no Aplicativo Web.
Quando a página é carregada, uma mensagem de erro é exibida na parte superior da página que indica que o site está sem espaço de armazenamento.
Lista do SharePoint no host da Web (cenário de Casos de Suporte)
O cenário casos de suporte exibe dados armazenados em uma lista do SharePoint no host da Web. Esse cenário usa dois padrões diferentes para acessar e interagir com os dados. O primeiro padrão inclui o Serviço de Pesquisa do SharePoint e a Web Part Conteúdo por Pesquisa com um modelo de exibição personalizado aplicado. O segundo padrão inclui uma parte do aplicativo (web part cliente) que exibe uma exibição Model-View-Controller, que usa o SP. RequestExecutor classe para chamar a API REST do SharePoint.
Há várias vantagens em usar essa abordagem:
- Você pode consultar dados facilmente usando consultas REST simples ou código de modelo de objeto cliente.
- Você pode pesquisar dados no SharePoint.
- Você pode atualizar os metadados da lista e criar novas exibições para uma lista sem atualizar e reimplantar o suplemento. Essas alterações não afetarão o comportamento do suplemento.
- As listas no host da Web não são excluídas quando você desinstala o suplemento, a menos que o suplemento use o evento AppUninstalled para remover a lista e/ou excluir os dados.
A compensação dessas vantagens são as seguintes desvantagens:
- O host da Web limita a quantidade de dados que você pode armazenar em listas e o tamanho dos resultados da consulta. Se a sua empresa precisar armazenar e/ou consultar grandes conjuntos de dados, essa não é uma abordagem recomendada.
- Para consultas complexas, as listas não são executadas, bem como bancos de dados.
- Para fazer backup e restaurar dados, as listas não têm um desempenho tão bom quanto bancos de dados.
Os dados para esse cenário são armazenados em uma lista do SharePoint implantada no host da Web. Os dados são recuperados e exibidos por meio do seguinte:
- Uma Web Part de Pesquisa de Conteúdo.
- Uma parte do aplicativo implementada como uma exibição Model-View-Controller.
O código nessa exibição usa consultas REST para recuperar informações da lista, enquanto a Web Part de Pesquisa de Conteúdo usa o Serviço de Pesquisa do SharePoint para recuperar os dados. As duas abordagens demonstram a vantagem significativa dessa opção: você pode usar o Serviço de Pesquisa e as APIs REST/CSOM para recuperar informações de uma lista no host da Web.
Ao selecionar um cliente na lista de casos de suporte, você verá os dados de caso de suporte para esse cliente exibidos na Web Part e na parte do aplicativo. A Web Part pode não retornar conteúdo imediatamente, pois pode levar até 24 horas para que o Serviço de Pesquisa do SharePoint indexe os dados. Você também pode escolher o link Exibir Casos de Suporte no host da Web para ver uma exibição convencional dos dados da lista.
Interface do usuário para o cenário de Casos de Suporte
A Web Part de Pesquisa de Conteúdo implantada por este suplemento usa um modelo de exibição personalizado. A figura a seguir mostra onde, no diretório Assets do projeto Web, você pode encontrar a Web Part e o modelo associado.
Conteúdo do diretório Ativos do projeto Web
O código JavaScript a seguir que você encontrará no arquivo Views/SupportCaseAppPart/Index.cshtml usa a biblioteca entre domínios para invocar uma consulta REST na lista do SharePoint no host da Web.
function execCrossDomainRequest() {
var executor = new SP.RequestExecutor(appWebUrl);
executor.executeAsync(
{
url: appWebUrl + "/_api/SP.AppContextSite(@@target)" +
"/web/lists/getbytitle('Support Cases')/items" +
"?$filter=(FTCAM_CustomerID eq '" + customerID + "')" +
"&$top=30" +
"&$select=Id,Title,FTCAM_Status,FTCAM_CSR" +
"&@@target='" + hostWebUrl + "'",
method: "GET",
headers: { "Accept": "application/json; odata=verbose" },
success: successHandler,
error: errorHandler
}
);
}
Você pode adicionar 5.000 itens à lista para mostrar que as consultas de lista que geram um conjunto de resultados de 5.000 ou mais itens atingem o limite de consulta de lista e falham. Esse cenário mostra uma das limitações mais importantes dessa abordagem: listar limites de tamanho de consulta. Se sua empresa precisar que você trabalhe com grandes dados e conjuntos de resultados de consulta, essa abordagem não funcionará. Para obter mais informações, consulte limite de consulta de lista anteriormente neste artigo.
Serviço Web Northwind OData (cenário do Painel do Cliente)
O cenário painel do cliente usa JQuery AJAX para invocar o serviço NorthWind OData para retornar informações do cliente. O suplemento armazena seus dados em um serviço Web e, em seguida, usa OData recuperá-los.
A seguir estão as vantagens de usar essa abordagem:
- Um determinado serviço Web pode dar suporte a vários suplementos.
- Você pode atualizar seu serviço Web sem precisar atualizar e reimplantar seus suplementos.
- Suas instalações do SharePoint e do serviço Web não afetam umas às outras.
- Serviços de hospedagem como Microsoft Azure permitem que você dimensione seus serviços Web.
- Você pode fazer backup e restaurar informações em seus serviços Web separadamente do seu site do SharePoint.
- Você não perde dados ao desinstalar o suplemento, a menos que o suplemento use o evento AppUninstalled para excluir os dados.
O cenário painel do cliente armazena seus dados em um serviço Web que implementa o padrão OData para recuperar dados. Na interface do painel do cliente, você seleciona um cliente em um menu suspenso e as informações do cliente são exibidas no painel Informações do Cliente.
Esta página da interface do usuário é uma exibição Model-View-Controller. A exibição é definida no arquivo Views/CustomerDashboard/Home.cshtml. O código subjacente está no arquivo Scripts/CustomerDashboard.js. O código JavaScript usa o AJAX para consultar o serviço Web Northwind. Como esse é um serviço OData, a consulta de serviço Web consiste em argumentos de cadeia de caracteres de consulta anexados a uma URL que aponta para um ponto de extremidade de serviço Web. O serviço retorna informações do cliente no formato JSON.
O código a seguir é executado quando você escolhe o link Painel Cliente. Ele recupera todos os nomes e IDs do cliente para preencher o menu suspenso.
var getCustomerIDsUrl = "https://odatasampleservices.azurewebsites.net/V3/Northwind/Northwind.svc/Customers?$format=json&$select=CustomerID";
$.get(getCustomerIDsUrl).done(getCustomerIDsDone)
.error(function (jqXHR, textStatus, errorThrown) {
$('#topErrorMessage').text('Can\'t get customers. An error occurred: ' + jqXHR.statusText);
});
O código a seguir é executado quando você seleciona um nome de cliente no menu suspenso. Ele usa o argumento OData $filter para especificar a ID do cliente e outros argumentos de cadeia de caracteres de consulta para recuperar informações relacionadas a esse cliente.
var url = "https://odatasampleservices.azurewebsites.net/V3/Northwind/Northwind.svc/Customers?$format=json" + "&$select=CustomerID,CompanyName,ContactName,ContactTitle,Address,City,Country,Phone,Fax" + "&$filter=CustomerID eq '" + customerID + "'";
$.get(url).done(getCustomersDone)
.error(function (jqXHR, textStatus, errorThrown) {
alert('Can\'t get customer ' + customerID + '. An error occurred: ' +
jqXHR.statusText);
});
Armazenamento de Tabelas do Azure (cenário de Pesquisa de Atendimento ao Cliente)
O cenário de Pesquisa de Atendimento ao Cliente permite que um representante de atendimento ao cliente veja sua classificação com base em pesquisas de clientes e usa o Armazenamento de Tabelas do Azure e a API Microsoft.WindowsAzure.Storage.Table.CloudTable para armazenar e interagir com os dados.
A seguir estão as vantagens de usar essa abordagem:
- O Armazenamento de Tabelas do Azure dá suporte a mais de um suplemento.
- Você pode atualizar o Armazenamento de Tabelas do Azure sem precisar atualizar e reimplantar o suplemento.
- A instalação do SharePoint e o armazenamento de Tabelas do Azure não têm efeito sobre o desempenho uns dos outros.
- O armazenamento de Tabelas do Azure é dimensionado facilmente.
- Você pode fazer backup e restaurar o armazenamento de Tabelas do Azure separadamente do site do SharePoint.
- Você não perde dados ao desinstalar o suplemento, a menos que o suplemento use o evento AppUninstalled para excluir os dados.
A interface do suplemento exibe a classificação de pesquisa do usuário atual na página central. Se esse armazenamento de Tabelas do Azure estiver vazio, o suplemento adicionará algumas informações à tabela antes de exibi-la.
O código a seguir do CSRInfoController.cs define o método Home que recupera o nameId do usuário.
[SharePointContextFilter]
public ActionResult Home()
{
var context =
SharePointContextProvider.Current.GetSharePointContext(HttpContext);
var sharePointService = new SharePointService(context);
var currentUser = sharePointService.GetCurrentUser();
ViewBag.UserName = currentUser.Title;
var surveyRatingsService = new SurveyRatingsService();
ViewBag.Score = surveyRatingsService.GetUserScore(currentUser.UserId.NameId);
return View();
}
O código a seguir do arquivo SurveyRatingService.cs define o construtor SurveyRatingsService, que configura a conexão com a conta de Armazenamento do Azure.
public SurveyRatingsService(string storageConnectionStringConfigName =
"StorageConnectionString")
{
var connectionString = Util.GetConfigSetting("StorageConnectionString");
var storageAccount = CloudStorageAccount.Parse(connectionString);
this.tableClient = storageAccount.CreateCloudTableClient();
this.surveyRatingsTable = this.tableClient.GetTableReference("SurveyRatings");
this.surveyRatingsTable.CreateIfNotExists();
}
O código a seguir do mesmo arquivo define o método GetUserScore, que recupera a pontuação de pesquisa do usuário do armazenamento de Tabelas do Azure.
public float GetUserScore(string userName)
{
var query = new TableQuery<Models.Customer>()
.Select(new List<string> { "Score" })
.Where(TableQuery.GenerateFilterCondition("Name",
QueryComparisons.Equal, userName));
var items = surveyRatingsTable
.ExecuteQuery(query)
.ToArray();
if (items.Length == 0)
return AddSurveyRatings(userName);
return (float)items.Average(c => c.Score);
}
Se a tabela não contiver nenhum dado de pesquisa relacionado ao usuário atual, o método AddSurveyRating atribuirá aleatoriamente uma pontuação para o usuário.
private float AddSurveyRatings(string userName)
{
float sum = 0;
int count = 4;
var random = new Random();
for (int i = 0; i < count; i++)
{
var score = random.Next(80, 100);
var customer = new Models.Customer(Guid.NewGuid(), userName, score);
var insertOperation = TableOperation.Insert(customer);
surveyRatingsTable.Execute(insertOperation);
sum += score;
}
return sum / count;
}
Armazenamento de Filas do Azure (cenário de Fila de Chamadas do Cliente)
O cenário fila de chamadas do cliente lista chamadores na fila de suporte e simula a realização de chamadas. O cenário usa o Armazenamento de Filas do Azure para armazenar dados e o Microsoft.WindowsAzure.Storage.Queue.CloudQueue API com Model-View-Controller.
A seguir estão as vantagens de usar essa abordagem:
- O Armazenamento de Filas do Azure dá suporte a mais de um suplemento.
- Você pode atualizar o Armazenamento de Filas do Azure sem precisar atualizar e reimplantar o suplemento.
- A instalação do SharePoint e o armazenamento de Filas do Azure não têm efeito sobre o desempenho uns dos outros.
- O armazenamento de Filas do Azure é dimensionado facilmente.
- Você pode fazer backup e restaurar o armazenamento de Filas do Azure separadamente do site do SharePoint.
- Você não perde dados ao desinstalar o suplemento, a menos que o suplemento use o evento AppUninstalled para excluir os dados.
A interface do suplemento exibe uma fila de chamadas de suporte no painel central quando você escolhe o link Fila de Chamadas suporte. Você pode simular o recebimento de chamadas (adicionando uma chamada à fila) escolhendo Simular Chamadase pode simular a realização da chamada mais antiga (removendo uma chamada da fila) escolhendo ação Executar Chamada associada a uma determinada chamada.
Esta página é uma exibição Model-View-Controller definida no arquivo Views/CallQueue/Home.cshtml. O arquivo Controllers/CallQueueController.cs define a classe CallQueueController, que contém métodos para recuperar todas as chamadas na fila, adicionar uma chamada à fila (simular uma chamada) e remover uma chamada da fila (fazer uma chamada). Cada um desses métodos chama métodos definidos no arquivo Services/CallQueueService.cs, que usa a API de armazenamento de Filas do Azure para recuperar as informações subjacentes na fila de armazenamento.
public class CallQueueController : Controller
{
public CallQueueService CallQueueService { get; private set; }
public CallQueueController()
{
CallQueueService = new CallQueueService();
}
// GET: CallQueue
public ActionResult Home(UInt16 displayCount = 10)
{
var calls = CallQueueService.PeekCalls(displayCount);
ViewBag.DisplayCount = displayCount;
ViewBag.TotalCallCount = CallQueueService.GetCallCount();
return View(calls);
}
[HttpPost]
public ActionResult SimulateCalls(string spHostUrl)
{
int count = CallQueueService.SimulateCalls();
TempData["Message"] = string.Format("Successfully simulated {0} calls and added them to the call queue.", count);
return RedirectToAction("Index", new { SPHostUrl = spHostUrl });
}
[HttpPost]
public ActionResult TakeCall(string spHostUrl)
{
CallQueueService.DequeueCall();
TempData["Message"] = "Call taken successfully and removed from the call queue!";
return RedirectToAction("Index", new { SPHostUrl = spHostUrl });
}
}
O arquivo CallQueueService.cs define a classe CallQueueService, que estabelece a conexão com o Armazenamento de Filas do Azure. Essa classe também contém os métodos para adicionar, remover (remover) e recuperar as chamadas da fila.
public class CallQueueService
{
private CloudQueueClient queueClient;
private CloudQueue queue;
public CallQueueService(string storageConnectionStringConfigName = "StorageConnectionString")
{
var connectionString = CloudConfigurationManager.GetSetting(storageConnectionStringConfigName);
var storageAccount = CloudStorageAccount.Parse(connectionString);
this.queueClient = storageAccount.CreateCloudQueueClient();
this.queue = queueClient.GetQueueReference("calls");
this.queue.CreateIfNotExists();
}
public int? GetCallCount()
{
queue.FetchAttributes();
return queue.ApproximateMessageCount;
}
public IEnumerable<Call> PeekCalls(UInt16 count)
{
var messages = queue.PeekMessages(count);
var serializer = new JavaScriptSerializer();
foreach (var message in messages)
{
Call call = null;
try
{
call = serializer.Deserialize<Call>(message.AsString);
}
catch { }
if (call != null) yield return call;
}
}
public void AddCall(Call call)
{
var serializer = new JavaScriptSerializer();
var content = serializer.Serialize(call);
var message = new CloudQueueMessage(content);
queue.AddMessage(message);
}
public void DequeueCall()
{
var message = queue.GetMessage();
queue.DeleteMessage(message);
}
public int SimulateCalls()
{
Random random = new Random();
int count = random.Next(1, 6);
for (int i = 0; i < count; i++)
{
int phoneNumber = random.Next();
var call = new Call
{
ReceivedDate = DateTime.Now,
PhoneNumber = phoneNumber.ToString("+1-000-000-0000")
};
AddCall(call);
return count;
}
}
Banco de Dados SQL do Azure (cenário de Pedidos Recentes)
O cenário Pedidos Recentes usa uma chamada direta para a Banco de Dados SQL do Azure Northwind para retornar todos os pedidos de um determinado cliente.
A seguir estão as vantagens de usar essa abordagem:
- Um banco de dados pode dar suporte a mais de um suplemento.
- Você pode atualizar o esquema de banco de dados sem precisar atualizar e reimplantar o suplemento, desde que as alterações de esquema não afetem as consultas no suplemento.
- Um banco de dados relacional pode dar suporte a relações muitos para muitos e, portanto, dar suporte a cenários de negócios mais complexos.
- Você pode usar ferramentas de design de banco de dados para otimizar o design do banco de dados.
- Os bancos de dados relacionais fornecem melhor desempenho do que as outras opções quando você precisa executar operações complexas em suas consultas, como cálculos e junções.
- Um Banco de Dados SQL do Azure permite importar e exportar dados facilmente, para que seja mais fácil gerenciar e mover seus dados.
- Você não perde nenhum dado ao desinstalar o suplemento, a menos que o suplemento use o evento AppUninstalled para excluir os dados.
A interface de pedidos recentes funciona muito como a interface do painel do cliente. Escolha o link Pedidos Recentes na coluna esquerda e escolha um cliente no menu suspenso na parte superior do painel central. Uma lista de pedidos desse cliente aparece no painel central.
Esta página é uma exibição Model-View-Controller definida no arquivo Views/CustomerDashboard/Orders.cshtml. O código no arquivo Controllers/CustomerDashboardController.cs usa o Entity Framework para consultar a tabela Orders em seu Banco de Dados SQL do Azure. A ID do cliente é passada usando um parâmetro de cadeia de caracteres de consulta na URL que é passada quando o usuário seleciona um cliente no menu suspenso. A consulta cria uma junção nas tabelas Customer, Employeee Shipper. O resultado da consulta é passado para a exibição Model-View-Controller que exibe os resultados.
O código a seguir do arquivo CustomerDashboardController.cs executa a consulta de banco de dados e retorna os dados para a exibição.
public ActionResult Orders(string customerId)
{
Order[] orders;
using (var db = new NorthWindEntities())
{
orders = db.Orders
.Include(o => o.Customer)
.Include(o => o.Employee)
.Include(o => o.Shipper)
.Where(c => c.CustomerID == customerId)
.ToArray();
}
ViewBag.SharePointContext =
SharePointContextProvider.Current.GetSharePointContext(HttpContext);
return View(orders);
}