protected void listView1_SelectedIndexChanged(object sender, EventArgs e)
{
if (listView1.SelectedIndex > -1)
{
spreadsheetName = listView1.SelectedItem.Text;
}
else
{
return;
}
if (spreadsheetName.Length > 0)
{
SpreadsheetsService GoogleExcelService;
GoogleExcelService = new SpreadsheetsService("Spreadsheet-Abhishek-Test-App");
GoogleExcelService.setUserCredentials("*****@*****.**", "Lucknow@");
SpreadsheetQuery query = new SpreadsheetQuery();
SpreadsheetFeed myFeed = GoogleExcelService.Query(query);
foreach (SpreadsheetEntry mySpread in myFeed.Entries)
{
if (mySpread.Title.Text == spreadsheetName)
{
WorksheetFeed wfeed = mySpread.Worksheets;
listView2.Items.Clear();
foreach (WorksheetEntry wsheet in wfeed.Entries)
{
string[] row = { wsheet.Title.Text, wsheet.Cols.ToString(), wsheet.Rows.ToString(), wsheet.Summary.Text };
System.Web.UI.WebControls.ListItem listItem = new System.Web.UI.WebControls.ListItem(wsheet.Title.Text);
listView2.Items.Add(listItem);
}
}
}
}
}
private static WorksheetEntry GetWorkSheetEntry(string sheetId)
{
WorksheetEntry wsEntry = null;
try
{
if (null == sheetsService)
{
sheetsService = GetUserCredential();
}
if (null != sheetsService)
{
WorksheetQuery worksheetquery = new WorksheetQuery("https://spreadsheets.google.com/feeds/worksheets/" + sheetId + "/private/full");
WorksheetFeed wsFeed = sheetsService.Query(worksheetquery);
if (wsFeed.Entries.Count > 0)
{
wsEntry = (WorksheetEntry)wsFeed.Entries[0];
}
if (null != wsEntry)
{
//create headers if missing
bool updatedHeaders = UpdateHeaders(wsEntry);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to get Google Worksheet.\n" + ex.Message, "Get Work Sheet Entry", MessageBoxButton.OK, MessageBoxImage.Warning);
}
return(wsEntry);
}
private List <CellFeed> DoCellQuery(SpreadsheetsService service, WorksheetFeed wsFeed, uint minRow, uint minColumn, uint maxColumn)
{
List <CellFeed> cellFeeds = new List <CellFeed>();
int i = 0;
foreach (WorksheetEntry worksheet in wsFeed.Entries)
{
if (worksheet.Title.Text[0] != '0')
{
CellQuery cellQuery = new CellQuery(worksheet.CellFeedLink);
cellQuery.MinimumRow = minRow;
cellQuery.MinimumColumn = minColumn;
cellQuery.MaximumColumn = maxColumn;
CellFeed cellFeed = service.Query(cellQuery);
cellFeeds.Insert(i, cellFeed);
i++;
}
else
{
CellFeed cellFeed = null;
cellFeeds.Insert(i, cellFeed);
i++;
}
}
return(cellFeeds);
}
private string ToGoogleTable()
{
WorksheetFeed wsFeed = TargetTable.Worksheets;
WorksheetEntry worksheet = (WorksheetEntry)wsFeed.Entries[0];
// Define the URL to request the list feed of the worksheet.
AtomLink listFeedLink = worksheet.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
// Fetch the list feed of the worksheet.
ListQuery listQuery = new ListQuery(listFeedLink.HRef.ToString());
ListFeed listFeed = service.Query(listQuery);
CellQuery cellQuery = new CellQuery(worksheet.CellFeedLink);
CellFeed cellFeed = service.Query(cellQuery);
CellEntry cellEntry = new CellEntry(1, 1, "oid");
cellFeed.Insert(cellEntry);
cellEntry = new CellEntry(1, 2, "value");
cellFeed.Insert(cellEntry);
cellEntry = new CellEntry(1, 3, "type");
cellFeed.Insert(cellEntry);
ProgressBarSetStartParams(progressBar1, ListData[ListData.Count - 1].Count);
tabControlShow(progressBar1);
tabControlShow(label3);
for (int i = 0; i < ListData[ListData.Count - 1].Count; i++)
{
IncrementProgressbar(progressBar1);
IncrementGeneralLabel(string.Format("Выполнено {0}/{1}", i + 1, ListData[ListData.Count - 1].Count));
service.Insert(listFeed, ListData[ListData.Count - 1].GetCustom(i));
}
tabControlShow(progressBar1, false);
tabControlShow(label3, false);
return("Данные записаны");
}
public WorksheetEntry GetWorksheetEntry(string name)
{
/*
* var link = entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
* var wsFeed = (WorksheetFeed) client.SpreadsheetService.Query(new WorksheetQuery(link.HRef.ToString()) {Title = name, Exact = true});
* if (wsFeed.Entries.Count == 0)
* return null;
*
* return (WorksheetEntry)wsFeed.Entries [0];
*/
SpreadsheetEntry spreadsheet = this.entry as SpreadsheetEntry;
WorksheetFeed wsFeed = spreadsheet.Worksheets;
// Iterate through each worksheet in the spreadsheet.
WorksheetEntry worksheetEntry = null;
foreach (WorksheetEntry entry in wsFeed.Entries)
{
// Retrieve worksheet with the given name.
if (entry.Title.Text == name)
{
worksheetEntry = entry;
}
}
return(worksheetEntry);
}
private void GetSpreadsheet(SpreadsheetsService service)
{
SpreadsheetQuery query = new SpreadsheetQuery();
SpreadsheetFeed feed = service.Query(query);
SpreadsheetEntry spreadsheet = null;
foreach (SpreadsheetEntry entry in feed.Entries)
{
if (!entry.Title.Text.Equals("Boardgame Stats"))
{
continue;
}
spreadsheet = entry;
}
if (spreadsheet == null)
{
MessageBox.Show("You don't appear to have access to the proper spreadsheet.");
return;
}
WorksheetFeed wsFeed = spreadsheet.Worksheets;
Games = wsFeed;
GetGameDateName(service, spreadsheet, wsFeed);
}
/// <summary>
/// Sets the list view on the Worksheets page with the titles of the worksheets,
/// and the row and column counts for demonstration of these extension elements
/// </summary>
/// <param name="feed">The worksheets feed for the spreadsheet selected on the Spreadsheets page</param>
void SetWorksheetListView(WorksheetFeed feed)
{
this.worksheetListView.Items.Clear();
AtomEntryCollection entries = feed.Entries;
for (int i = 0; i < entries.Count; i++)
{
// Get the cells feed URI
AtomLink cellsLink = entries[i].Links.FindService(GDataSpreadsheetsNameTable.CellRel, AtomLink.ATOM_TYPE);
// Get the list feed URI
AtomLink listLink = entries[i].Links.FindService(GDataSpreadsheetsNameTable.ListRel, AtomLink.ATOM_TYPE);
// Create an item that will display the title and hide the cells and list feed URIs
ListViewItem item = new ListViewItem(new string[3] {
entries[i].Title.Text + " (Rows:"
+ ((WorksheetEntry)entries[i]).RowCount.Count
+ ", Cols:" + ((WorksheetEntry)entries[i]).ColCount.Count + ")",
cellsLink.HRef.Content, listLink.HRef.Content
});
this.worksheetListView.Items.Add(item);
}
}
//Fetch all worksheets for given Spreadsheet
public static ArrayList getWorksheetList(string userName, string passWord, string spreadSheetName)
{
ArrayList worksheetList = new ArrayList();
SpreadsheetsService service = new SpreadsheetsService(spreadSheetName + "Service");
//You could set it up from DB or config file also. This is not a reccomended way. Just an easy way to show fetching
service.setUserCredentials(userName, passWord);
SpreadsheetQuery query = new SpreadsheetQuery();
SpreadsheetFeed feed = service.Query(query);
foreach (SpreadsheetEntry entry in feed.Entries)
{
if (entry.Title.Text == spreadSheetName)
{
AtomLink link = entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery wquery = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed wfeed = service.Query(wquery);
foreach (WorksheetEntry worksheet in wfeed.Entries)
{
worksheetList.Add(worksheet.Title.Text);
}
}
}
return(worksheetList);
}
static void Main(string[] args)
{
Environment.CurrentDirectory = Environment.CurrentDirectory.Substring(0, Environment.CurrentDirectory.LastIndexOf("osum", StringComparison.Ordinal)) + @"\osum\osum\Localisation\";
ss.setUserCredentials("*****@*****.**", "osumisawsum");
SpreadsheetFeed feed = ss.Query(new SpreadsheetQuery());
SpreadsheetEntry sheet = null;
//get spreadsheet
foreach (var entry in feed.Entries.OfType <SpreadsheetEntry>())
{
if (entry.Title.Text == "osu!stream localisation")
{
sheet = entry;
break;
}
}
if (sheet == null)
{
Console.WriteLine("failed to get spreadsheet");
Console.ReadLine();
}
//get worksheet
AtomLink link = sheet.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery query = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed wfeed = ss.Query(query);
WorksheetEntry worksheet = wfeed.Entries[0] as WorksheetEntry;
ProcessWorksheet(worksheet);
}
private static WorksheetEntry GetWorksheet()
{
AtomLink link = sheet.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery query = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed wfeed = ss.Query(query);
return(wfeed.Entries[0] as WorksheetEntry);
}
public Google2uManualWorkbook(WorksheetFeed in_feed, string in_url, string in_name, Service in_service)
{
_Service = in_service;
WorkbookUrl = in_url;
Workbook = in_feed;
WorkbookName = in_name;
Worksheets = new List <Google2uWorksheet>();
}
public CellFeed GetCellFeed(int sheetNum)
{
WorksheetFeed wsFeed = spreadSheetEntry.Worksheets;
WorksheetEntry worksheet = (WorksheetEntry)wsFeed.Entries[sheetNum];
CellQuery cellQuery = new CellQuery(worksheet.CellFeedLink);
CellFeed cellFeed = service.Query(cellQuery);
return(cellFeed);
}
protected void button2_Click(object sender, EventArgs e)
{
if (spreadsheetName.Length > 0)
{
if (listView2.SelectedIndex > -1)
{
wrkSheetName = listView2.SelectedItem.Text;
}
else
{
return;
}
SpreadsheetsService GoogleExcelService;
GoogleExcelService = new SpreadsheetsService("Spreadsheet-Abhishek-App");
GoogleExcelService.setUserCredentials("*****@*****.**", "Lucknow@");
// ListQuery query = new ListQuery("0AmYgMIof-5mgdGM2OGxoTmUyc3JRTFlMZ1BTUG5SOVE", "1", "public", "values");
// ListQuery query = new ListQuery("https://docs.google.com/a/laitkor.com/spreadsheet/ccc?key=0AttN4WWVg0qodF9RSG8tOXptV0RwZm1LOWFJQ3g0Mnc#gid=0", "1", "public", "values");
//ListFeed myFeed = GoogleExcelService.Query(query);
SpreadsheetQuery query = new SpreadsheetQuery();
SpreadsheetFeed myFeed = GoogleExcelService.Query(query);
foreach (SpreadsheetEntry mySpread in myFeed.Entries)
{
if (mySpread.Title.Text == spreadsheetName)
{
WorksheetFeed wfeed = mySpread.Worksheets;
foreach (WorksheetEntry wsheet in wfeed.Entries)
{
if (wsheet.Title.Text == wrkSheetName)
{
AtomLink atm = wsheet.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
ListQuery Lquery = new ListQuery(atm.HRef.ToString());
ListFeed LFeed = GoogleExcelService.Query(Lquery);
myTable = new DataTable();
DataColumn DC;
foreach (ListEntry LmySpread in LFeed.Entries)
{
DataRow myDR = myTable.NewRow();
foreach (ListEntry.Custom listrow in LmySpread.Elements)
{
DC = myTable.Columns[listrow.LocalName] ?? myTable.Columns.Add(listrow.LocalName);
myDR[DC] = listrow.Value;
}
myTable.Rows.Add(myDR);
}
dataGridView1.DataSource = myTable;
dataGridView1.DataBind();
}
}
}
}
}
//System.Windows.Forms.MessageBox.Show("Data Reading is Completed");
ClientScript.RegisterStartupScript(this.GetType(), "myalert", "alert('Data Reading is Completed');", true);
}
public ListFeed GetListFeed(int sheetNum)
{
WorksheetFeed wsFeed = spreadSheetEntry.Worksheets;
WorksheetEntry worksheet = (WorksheetEntry)wsFeed.Entries[sheetNum];
AtomLink listFeedLink = worksheet.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
ListQuery listQuery = new ListQuery(listFeedLink.HRef.ToString());
return(service.Query(listQuery));
}
public List <Worksheet> ListWorksheets()
{
AtomLink link = _entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery query = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed feed = _service.Query(query);
return(CollectionUtils.Map <WorksheetEntry, Worksheet, List <Worksheet> >(
feed.Entries,
delegate(WorksheetEntry entry) { return new Worksheet(_service, entry); }));
}
private CellFeed GetCellFeed(SpreadsheetsService service, SpreadsheetEntry spEntry)
{
WorksheetFeed wsFeed = spEntry.Worksheets;
WorksheetEntry wsEntry = (WorksheetEntry)wsFeed.Entries[0];
AtomLink wLink = wsEntry.Links.FindService(GDataSpreadsheetsNameTable.CellRel, null);
CellQuery cellQuery = new CellQuery(wLink.HRef.ToString());
CellFeed cellFeed = service.Query(cellQuery);
return(cellFeed);
}
public async Task ExportToDocumentAsync <TModel>(string path, IReadOnlyList <ResGroupModel <TModel> > groups, IStatusProgress progress, CancellationToken cancellationToken) where TModel : IRowModel
{
progress.Report(StatusRes.GettingSpreadsheet);
SpreadsheetFeed spreadSheets = await Service.GetFeedAsync(new SpreadsheetQuery(path), progress, cancellationToken);
SpreadsheetEntry spreadsheet = (SpreadsheetEntry)spreadSheets.Entries.First();
progress.Report(StatusRes.GettingWorksheets);
WorksheetFeed worksheetsFeed = await Service.GetFeedAsync(spreadsheet.GetWorkSheetQuery(), progress, cancellationToken);
int columsCount = groups.First().Tables.First().Rows.First().DataList.Count;
List <KeyValuePair <string, WorksheetEntry> > newWorksheets = groups
.Select(g => new KeyValuePair <string, WorksheetEntry>(g.GroupTitle, new WorksheetEntry((uint)(g.Tables.Sum(t => t.Rows.Count + 3) + /*Table name rows*/ g.Tables.Count - 1), (uint)columsCount, g.GroupTitle)))
.ToList();
List <WorksheetEntry> worksheets2Rename = worksheetsFeed.Entries.Cast <WorksheetEntry>()
.Where(ws => newWorksheets.Any(nws => String.Equals(nws.Key, ws.Title.Text, StringComparison.OrdinalIgnoreCase)))
.ToList();
if (worksheets2Rename.Count != 0)
{
foreach (var worksheetEntry in worksheets2Rename)
{
worksheetEntry.Title.Text = Guid.NewGuid().ToString("N");
worksheetEntry.BatchData = new GDataBatchEntryData(GDataBatchOperationType.update);
}
progress.Report(StatusRes.RenamingOldWorksheets);
var progresses = progress.CreateParallelProgresses(worksheets2Rename.Count);
//Renaming worksheets with matching names.
await Task.WhenAll(worksheets2Rename.Zip(progresses, (ws, p) => Service.UpdateItemAsync(ws, p, cancellationToken)));
}
progress.Report(StatusRes.InsertingNewWorksheets);
//Creating new worksheets.
var insertingProgresses = progress.CreateParallelProgresses(newWorksheets.Count);
var createdWorksheets = await Task.WhenAll(newWorksheets.Zip(insertingProgresses, (kvp, p) => Service.InsertItemAsync(spreadsheet.GetWorkSheetLink(), kvp.Value, p, cancellationToken)));
newWorksheets = createdWorksheets.Select(ws => new KeyValuePair <string, WorksheetEntry>(ws.Title.Text, ws)).ToList();
progress.Report(StatusRes.DeletingOldWorksheets);
//Clearing of previous worksheets.
var deletingProgresses = progress.CreateParallelProgresses(worksheetsFeed.Entries.Count);
await Task.WhenAll(worksheetsFeed.Entries.Cast <WorksheetEntry>().Zip(deletingProgresses, (ws, p) => Service.DeleteItemAsync(ws, p, cancellationToken)).ToArray());
progress.Report(StatusRes.PushingCells);
var groupWorksheetsJoin = newWorksheets.Join(groups, ws => ws.Key, g => g.GroupTitle, (kvp, group) => new { Group = group, Worksheet = kvp.Value }).ToList();
var groupProgresses = progress.CreateParallelProgresses(groupWorksheetsJoin.Select(j => (double)j.Worksheet.Cols * j.Worksheet.Rows).ToList());
SemaphoreSlim semaphore = new SemaphoreSlim(MaxPushRequestsCount);
await Task.WhenAll(groupWorksheetsJoin.Zip(groupProgresses, (j, p) => PushCellsAsync(j.Worksheet, j.Group, semaphore, p, cancellationToken)));
}
private List <DatablockDetectionInfo> ParseSpreadsheet(SpreadsheetEntry spreadsheet)
{
WorksheetFeed wsFeed = spreadsheet.Worksheets;
if (wsFeed.Entries.Count == 0)
{
return(null);
}
var worksheet = (WorksheetEntry)wsFeed.Entries[0];
if (worksheet.Rows < 2)
{
return(null);
}
// Define the URL to request the list feed of the worksheet.
AtomLink listFeedLink = worksheet.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
// Fetch the list feed of the worksheet.
var listQuery = new ListQuery(listFeedLink.HRef.ToString());
ListFeed listFeed = sheetsAPI.Service.Query(listQuery);
var headers = new List <string>();
spreadsheetRows = listFeed.Entries;
nameColumnIndex = -1;
var row = (ListEntry)spreadsheetRows[0];
for (int index = 0; index < row.Elements.Count; index++)
{
ListEntry.Custom element = row.Elements[index];
if (element.LocalName.Equals("name", StringComparison.OrdinalIgnoreCase))
{
nameColumnIndex = index;
}
headers.Add(element.LocalName);
}
List <DatablockDetectionInfo> datablockTypes = AutoDetectDatablockType(headers);
if (datablockTypes == null)
{
Debug.Log("Unable to auto detect datablock type");
return(null);
}
return(datablockTypes);
}
/// <summary>
/// Load a worksheet from the selected spreadsheet
/// </summary>
/// <param name="spreadsheet"></param>
/// <param name="workSheetName"></param>
/// <returns></returns>
public static GS2U_Worksheet LoadWorkSheet(this GS2U_SpreadSheet spreadsheet, string workSheetName)
{
WorksheetFeed wsFeed = spreadsheet.spreadsheetEntry.Worksheets;
foreach (WorksheetEntry ws in wsFeed.Entries)
{
if (ws.Title.Text == workSheetName)
{
return(new GS2U_Worksheet(ws));
}
}
return(null);
}
public List <TDataRow> ReadAll <TDataRow>(String documentName, String sheetTitle) where TDataRow : GdataRow, new()
{
SpreadsheetQuery sheetQuery = new SpreadsheetQuery();
SpreadsheetFeed sheetFeed = AuthorisedSpreadsheetsService.Query(sheetQuery);
AtomEntry affiliates = (from x in sheetFeed.Entries where x.Title.Text.Contains(documentName) select x).First();
// Get the first Worksheet...
AtomLink sheetLink = affiliates.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery workSheetQuery = new WorksheetQuery(sheetLink.HRef.ToString());
WorksheetFeed workSheetFeed = AuthorisedSpreadsheetsService.Query(workSheetQuery);
AtomEntry affiliateSheet = workSheetFeed.Entries.First(s => s.Title.Text.Equals(sheetTitle, StringComparison.InvariantCultureIgnoreCase));
// Get the cells...
UInt32 startRow = 2;
AtomLink cellLink = affiliateSheet.Links.FindService(GDataSpreadsheetsNameTable.CellRel, null);
CellQuery cellQuery = new CellQuery(cellLink.HRef.ToString())
{
MinimumRow = startRow,
};
CellFeed cellFeed = AuthorisedSpreadsheetsService.Query(cellQuery);
List <TDataRow> table = new List <TDataRow>();
TDataRow row = null;
foreach (CellEntry currentCell in cellFeed.Entries)
{
if (currentCell.Column == 1)
{
if (currentCell.Value.Equals("-end-", StringComparison.InvariantCultureIgnoreCase))
{
break;
}
row = new TDataRow {
RowNbr = currentCell.Row, Service = AuthorisedSpreadsheetsService, CellLink = cellLink
};
table.Add(row);
}
if (currentCell.Column > row.LastColumn)
{
continue;
}
row.SetValue(currentCell);
}
return(table);
}
private WorksheetEntry GetWorksheet(SpreadsheetEntry pSpreadsheetEntry)
{
AtomLink link = tDicingSpreadsheet.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
string tLink = link.HRef.ToString();
WorksheetQuery tWorksheetQuery = new WorksheetQuery(tLink);
tWorksheetQuery.Title = tSheetName;
WorksheetFeed wfeed = tService.Query(tWorksheetQuery);
WorksheetEntry wentry = wfeed.Entries.FirstOrDefault() as WorksheetEntry;
return(wentry);
}
public void SelectWorkSheet(string sSheetName)
{
WorksheetQuery worksheetQuery = new WorksheetQuery(m_oLink.HRef.ToString());
worksheetQuery.Title = sSheetName;
m_oWorksheetFeed = m_oAccount.Service.Query(worksheetQuery);
m_oWorksheet = (WorksheetEntry)m_oWorksheetFeed.Entries[0];
AtomLink listFeedLink = m_oWorksheet.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
ListQuery listQuery = new ListQuery(listFeedLink.HRef.ToString());
m_oListFeed = m_oAccount.Service.Query(listQuery);
}
private void selectSpreadsheetButton_Click(object sender, RoutedEventArgs e)
{
if (spreadsheetsList.SelectedItem == null)
{
return;
}
_selectedSpreadsheet = (SpreadsheetEntry)spreadsheetsList.SelectedItem;
WorksheetFeed wsFeed = _selectedSpreadsheet.Worksheets;
spreadsheetsList.ItemsSource = wsFeed.Entries;
selectSpreadsheetButton.IsEnabled = false;
useWorksheetButton.IsEnabled = true;
useWriterButton.IsEnabled = false;
}
private List <WorksheetEntry> GetAllWorksheets(SpreadsheetEntry entry)
{
AtomLink listLink = entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, AtomLink.ATOM_TYPE);
WorksheetQuery query = new WorksheetQuery(listLink.HRef.ToString());
WorksheetFeed feed = spreadsheetService.Query(query);
var list = new List <WorksheetEntry>();
foreach (WorksheetEntry worksheet in feed.Entries)
{
list.Add(worksheet);
}
return(list);
}
private void GetLocalizationList()
{
if (string.IsNullOrEmpty(settings.spreadSheetKey))
{
Debug.LogError("spreadSheetKey can not be null!");
return;
}
PlayerPrefs.SetString(PREF_SHEET_KEY, settings.spreadSheetKey);
PlayerPrefs.Save();
if (IsTokkenEmpty)
{
EditorUtility.ClearProgressBar();
GetAccessCode();
return;
}
progressMessage = "Authenticating...";
GOAuth2RequestFactory requestFactory = RefreshAuthenticate();
SpreadsheetsService service = new SpreadsheetsService(appName);
service.RequestFactory = requestFactory;
SpreadsheetQuery query = new SpreadsheetQuery();
query.Uri = new System.Uri(urlRoot + settings.spreadSheetKey);
progressMessage = "Get list of spreadsheets...";
spreadsheetFeed = service.Query(query);
if ((spreadsheetFeed == null) || (spreadsheetFeed.Entries.Count <= 0))
{
Debug.LogError("Not found any data!");
EditorUtility.ClearProgressBar();
return;
}
AtomEntry mySpreadSheet = spreadsheetFeed.Entries[0];
AtomLink link = mySpreadSheet.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery sheetsQuery = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed sheetsFeed = service.Query(sheetsQuery);
foreach (WorksheetEntry sheet in sheetsFeed.Entries)
{
wantedSheetNames.Add(sheet.Title.Text);
}
localizationCount = wantedSheetNames.Count;
}
public GoogleSpreadsheetHelper(string spreadsheetId, SpreadsheetsService spreadsheetsService)
{
WorksheetFeed worksheetFeed = null;
_spreadsheetId = spreadsheetId;
Wait.UntilNumberOfExceptions(() =>
{
service = spreadsheetsService;
var spreadsheetLink = "https://spreadsheets.google.com/feeds/spreadsheets/" + _spreadsheetId;
var spreadsheetQuery = new SpreadsheetQuery(spreadsheetLink);
var spreadsheetFeed = service.Query(spreadsheetQuery);
var spreadsheetEntry = (SpreadsheetEntry)spreadsheetFeed.Entries[0];
worksheetFeed = spreadsheetEntry.Worksheets;
WorksheetEntry = (WorksheetEntry)worksheetFeed.Entries[0];
}, 60 * 1000);
}
/// <summary>
/// Prints a list of all worksheets in the specified spreadsheet.
/// </summary>
/// <param name="service">an authenticated SpreadsheetsService object</param>
/// <param name="entry">the spreadsheet whose worksheets are to be retrieved</param>
private static void PrintAllWorksheets(SpreadsheetsService service,
SpreadsheetEntry entry)
{
AtomLink link = entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery query = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed feed = service.Query(query);
Console.WriteLine("Worksheets in " + entry.Title.Text + ":");
foreach (WorksheetEntry worksheet in feed.Entries)
{
allWorksheets.Add(worksheet);
Console.WriteLine(" " + worksheet.Title.Text);
}
Console.WriteLine();
}
private void getAllWorksheets()
{
AtomLink link = m_spreadsheetEntry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery query = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed feed = m_service.Query(query);
Trace.WriteLine("Found " + feed.Entries.Count + " worksheets.");
Trace.Indent();
foreach (WorksheetEntry worksheet in feed.Entries)
{
Trace.WriteLine(worksheet.Title.Text);
m_worksheets.Add(worksheet.Title.Text, worksheet);
}
Trace.Unindent();
}
public static void SpreadSheetRead()
{
//Authenticate:
SpreadsheetsService myService = new SpreadsheetsService(null);
myService.setUserCredentials("yokolnov.logstream", "klamsi81");
//Get a list of spreadsheets:
SpreadsheetQuery query = new SpreadsheetQuery();
query.Uri = new Uri(@"https://docs.google.com/spreadsheets/d/19qX8B8skvYMRcmgMQhsek2ZHi1fdiyf1LC7wVm7D4L4/edit#gid=0");
SpreadsheetFeed feed = myService.Query(query);
Console.WriteLine("Your spreadsheets: ");
foreach (SpreadsheetEntry entry in feed.Entries)
{
Console.WriteLine(entry.Title.Text);
//Given a SpreadsheetEntry you've already retrieved, you can get a list of all worksheets in this spreadsheet as follows:
AtomLink link = entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
WorksheetQuery wsquery = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed wsfeed = myService.Query(wsquery);
foreach (WorksheetEntry worksheet in wsfeed.Entries)
{
Console.WriteLine(worksheet.Title.Text);
//And get a cell based feed:
AtomLink cellFeedLink = worksheet.Links.FindService(GDataSpreadsheetsNameTable.CellRel, null);
CellQuery cquery = new CellQuery(cellFeedLink.HRef.ToString());
CellFeed cfeed = myService.Query(cquery);
Console.WriteLine("Cells in this worksheet:");
foreach (CellEntry curCell in feed.Entries)
{
Console.WriteLine("Row {0}, column {1}: {2}", curCell.Cell.Row,
curCell.Cell.Column, curCell.Cell.Value);
}
}
}
}
/// <summary>
/// ワークシートを追加する
/// </summary>
/// <param name="name">ワークシート名</param>
/// <param name="columns">追加するカラム数</param>
/// <returns>作成されたワークシート</returns>
public static WorksheetEntry CreateWorksheet(this WorksheetFeed feed,
string name, int columns)
{
//現状、どっちでも動く
WorksheetEntry worksheet = (WorksheetEntry)feed.CreateFeedEntry();
// WorksheetEntry worksheet = new WorksheetEntry();
worksheet.Title.Text = name;
///columnsは規定数ないとCellFeed.Insertで死ぬ
worksheet.Cols = (uint)columns;
//rowsは勝手にListFeed.Insertで増えてく
worksheet.Rows = 1;
//追加する。追加された結果Entryを使って次の処理を行う
return(feed.Insert(worksheet));
}
