public JsonResult Upload()
{
SelectOptions select = new SelectOptions();
var resultList = new List <ViewDataUploadFilesResult>();
var CurrentContext = HttpContext;
var httpRequest = CurrentContext.Request;
foreach (String inputTagName in httpRequest.Files)
{
var headers = httpRequest.Headers;
var file = httpRequest.Files[inputTagName];
select.Text = file.FileName;
file_namelist.Add(select);
}
filesHelper.UploadAndShowResults(CurrentContext, resultList);
JsonFiles files = new JsonFiles(resultList);
bool isEmpty = !resultList.Any();
if (isEmpty)
{
return(Json("Error "));
}
else
{
return(Json(files));
}
ViewBag.Liste = file_namelist;
}
public Select(SelectOptions <T> options)
: base(false)
{
_paginator = new Paginator <T>(options.Items, options.PageSize, Optional <T> .Create(options.DefaultValue), options.TextSelector);
_options = options;
}
public async Task <IHttpActionResult> GetListAsync([FromUri] int id, [FromUri] int page = 0, [FromUri] int size = 10)
{
Post post = await UnitOfWork.GetPostRepository().SelectFirstOrDefaultAsync(p => p.Id == id && p.Status == Enums.PostStatus.Published)
?? throw new ActionCannotBeExecutedException(ExceptionMessages.PostNotFound);
SelectOptions <Comment> options = new SelectOptions <Comment>
{
OrderBy = p => p.OrderByDescending(t => t.Id),
Take = size,
Skip = page * size
};
StatusSpecification specification = new StatusSpecification(Enums.CommentStatus.Active);
ICommentRepository repo = UnitOfWork.GetCommentRepository();
IEnumerable <Comment> list = await repo.SelectAsync(specification, options);
int resultsCount = await repo.CountAsync(specification);
Paging paging = new Paging(page: page, count: resultsCount, size: size);
GetListResponse response = new GetListResponse(paging)
{
Items = list.Select(c => new GetListResponseItem
{
Id = c.Id,
UserId = c.UserId,
Comment = c.Body,
FirstName = c.User.FirstName,
Image = c.User.Image
})
};
return(Ok(response));
}
public async Task <IHttpActionResult> GetListAsync([FromUri] int page = 0, [FromUri] int size = 10)
{
SelectOptions <Tourney> options = new SelectOptions <Tourney>
{
OrderBy = p => p.OrderByDescending(t => t.Id),
Take = size,
Skip = page * size
};
IEnumerable <Tourney> results = await UnitOfWork.GetTourneyRepository().SelectAllAsync(options: options);
Paging paging = new Paging(count: results.Count(), page: page, size: size);
GetListResponse response = new GetListResponse(paging)
{
Items = results.Select(t => new GetListItem
{
Id = t.Id,
Name = t.Name,
EndDt = t.EndDt,
StartDt = t.StartDt
})
};
return(Ok(response));
}
public async Task LikeAsync(User user, int id)
{
SelectOptions <Post> options = new SelectOptions <Post>();
options.Includes.Add(p => p.Likes);
options.Includes.Add(p => p.Dislikes);
Post post = await _unitOfWork.GetPostRepository().SelectByIdAsync(id, options)
?? throw new ActionCannotBeExecutedException(ExceptionMessages.PostNotFound);
if (post.Dislikes.Contains(user))
{
post.Dislikes.Remove(user);
post.Likes.Add(user);
return;
}
if (post.Likes.Contains(user))
{
post.Likes.Remove(user);
return;
}
post.Likes.Add(user);
}
/// <summary>
/// Executes the select and returns the list of rows
/// </summary>
/// <param name="sql">The SQL.</param>
/// <param name="selectOptions">The select options.</param>
/// <returns>The list of rows</returns>
public IList <ISqlResult> ExecuteQuery(string sql, SelectOptions selectOptions)
{
if (SelectOptions.Single == selectOptions)
{
return(ExecuteSingleSelect(sql));
}
return(ExecuteMultiSelect(sql));
}
/// <summary>
/// Applys the Projection to the Queryable
/// </summary>
/// <param name="queryable">The Queryable</param>
/// <param name="options">The SelectOptions</param>
/// <returns>The queryable</returns>
public IQueryable <T> ApplyProjection <T>(IQueryable <T> queryable, SelectOptions <T> options) where T : SearchResultItem
{
if (options?.Expression != null)
{
queryable = queryable.Select(options.Expression);
}
return(queryable);
}
public IList <ISqlResult> ExecuteQuery(string _sql, SelectOptions selectOptions)
{
sql = _sql;
executedQueries.Add(sql);
return(new List <ISqlResult>
{
GetSqlResult()
});
}
private void InitalizeSelectViewRendering()
{
FormFieldName = Rendering.Parameters[MobileFieldNames.StandardFormViewRenderingParameters.FormFieldName];
if (Rendering.Item == null || string.IsNullOrEmpty(FormFieldName))
{
return;
}
FormFieldValueControllerName = Rendering.Parameters[MobileFieldNames.StandardFormViewRenderingParameters.FormFieldValueControllerName];
FormFieldValueControllerAction = Rendering.Parameters[MobileFieldNames.StandardFormViewRenderingParameters.FormFieldValueControllerAction];
DataInline = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataInline] == "1" ? "true" : "false";
DataMini = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataMini] == "1" ? "true" : "false";
DataRole = !string.IsNullOrEmpty(Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataRole]) ? Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataRole] : "";
string selectDataSource = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.SelectDataSource] ?? "";
//string selectFieldValue = Rendering.Parameters["SelectFieldValue"] ?? "Name";
//string selectFieldName = Rendering.Parameters["SelectFieldName"] ?? "__Display Name";
bool selectIncludeEmptyOption = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.SelectIncludeEmptyOption] == "1" ? true : false;
string fieldTitle = Rendering.Parameters[MobileFieldNames.StandardFormViewRenderingParameters.FormFieldTitle];
if (!string.IsNullOrEmpty(fieldTitle))
{
FormFieldLabel = fieldTitle;
}
if (selectIncludeEmptyOption)
{
SelectOptions.Add(new Tuple <string, string, Nullable <bool> >(string.Empty, string.Empty, null));
}
var selectDataItem = Sitecore.Context.Database.GetItem(selectDataSource);
if (selectDataItem != null && selectDataItem.HasChildren)
{
foreach (Sitecore.Data.Items.Item item in selectDataItem.Children)
{
SelectOptions.Add(new Tuple <string, string, Nullable <bool> >(item.Name, item.DisplayName, null));
}
}
if (!string.IsNullOrEmpty(FormFieldValueControllerName) &&
!string.IsNullOrEmpty(FormFieldValueControllerAction))
{
var r = new Sitecore.Mvc.Controllers.ControllerRunner(
FormFieldValueControllerName,
FormFieldValueControllerAction);
FormFieldValue = r.Execute();
// formFieldControllerValue = Html.Partial(Model.FormFieldValueControllerAction, Model.FormFieldValueControllerName);
}
}
protected bool IsCreatedTagOption()
{
if (SelectMode == SelectMode.Tags &&
!string.IsNullOrEmpty(_searchValue) &&
!SelectOptions.Any(option => option.Value == _searchValue))
{
return(true);
}
return(false);
}
public SelectForm(SelectOptions <T> options)
{
if (options.Items is null)
{
throw new ArgumentNullException(nameof(options.Items));
}
_paginator = new Paginator <T>(options.Items, options.PageSize, Optional <T> .Create(options.DefaultValue), options.TextSelector);
_options = options;
}
public static Array GetEnumValues(SelectOptions selector)
{
switch (selector)
{
case SelectOptions.Building: return(Enum.GetValues(typeof(BuildingSelector)));
case SelectOptions.Unit: return(Enum.GetValues(typeof(UnitSelector)));
default: return(Array.Empty <SelectOptions>());
}
}
private async Task <List <MessageData> > GetAllInternal(SelectOptions selectOptions)
{
var response = await this._space["Q"].Select <ValueTuple <uint>, ValueTuple <uint, string> >(ValueTuple.Create((uint)0), selectOptions);
var result = response.Data.Aggregate(new List <MessageData>(response.Data.Length),
(list, s) =>
{
list.Add(this._jsonService.Deserialize <MessageData>(s.Item2));
return(list);
});
return(result);
}
public async Task <T[]> Select <T>(object key = null, Iterator iterator = Iterator.Eq, uint limit = uint.MaxValue, uint offset = 0)
where T : class
{
var selectOptions = new SelectOptions
{
Iterator = iterator,
Limit = limit,
Offset = offset
};
return(await Select <T>(key, selectOptions));
}
public async Task <DataResponse <TTuple[]> > Select <TKey, TTuple>(TKey key, SelectOptions options = null)
{
var selectRequest = new SelectRequest <TKey>(
SpaceId,
Id,
options?.Limit ?? uint.MaxValue,
options?.Offset ?? 0,
options?.Iterator ?? Iterator.Eq,
key);
return(await LogicalConnection.SendRequest <SelectRequest <TKey>, TTuple>(selectRequest).ConfigureAwait(false));
}
private void InitalizeSelectViewRendering()
{
EditingEnabled = (Sitecore.Context.Site.DisplayMode == Sitecore.Sites.DisplayMode.Edit);
FieldName = Rendering.Parameters[MobileFieldNames.StandardViewRenderingParameters.FieldName];
if (Rendering.Item == null || string.IsNullOrEmpty(FieldName))
{
return;
}
DataInline = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataInline] == "1" ? "true" : "false";
DataMini = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataMini] == "1" ? "true" : "false";
DataRole = !string.IsNullOrEmpty(Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataRole]) ? Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.DataRole] : "";
string selectDataSource = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.SelectDataSource] ?? "";
//string selectFieldValue = Rendering.Parameters["SelectFieldValue"] ?? "Name";
//string selectFieldName = Rendering.Parameters["SelectFieldName"] ?? "__Display Name";
bool selectIncludeEmptyOption = Rendering.Parameters[MobileFieldNames.SelectViewRenderingParameters.SelectIncludeEmptyOption] == "1" ? true : false;
HiddenEditingField = Rendering.Parameters[MobileFieldNames.StandardViewRenderingParameters.HiddenEditingField] == "1" ? true : false;
if (HiddenEditingField && !EditingEnabled)
{
return;
}
bool displayFieldTitle = Rendering.Parameters[MobileFieldNames.StandardViewRenderingParameters.DisplayFieldTitle] == "1" ? true : false;
bool displayEditingFieldTitle = Rendering.Parameters[MobileFieldNames.StandardViewRenderingParameters.DisplayEditingFieldTitle] == "1" ? true : false;
if (displayFieldTitle ||
(displayEditingFieldTitle && EditingEnabled))
{
var itemField = Rendering.Item.Fields[FieldName];
var fieldItem = Rendering.Item.Database.GetItem(itemField.ID);
PageEditorLabel = string.Format("{0}:", fieldItem.DisplayName);
}
if (selectIncludeEmptyOption)
{
SelectOptions.Add(new Tuple <string, string, bool>(string.Empty, string.Empty, false));
}
var selectDataItem = Sitecore.Context.Database.GetItem(selectDataSource);
if (selectDataItem != null && selectDataItem.HasChildren)
{
foreach (Sitecore.Data.Items.Item item in selectDataItem.Children)
{
SelectOptions.Add(new Tuple <string, string, bool>(item.Name, item.DisplayName, false));
}
}
}
internal SelectExpression(Alias alias, bool distinct, Expression?top, IEnumerable <ColumnDeclaration>?columns, SourceExpression?from, Expression?where, IEnumerable <OrderExpression>?orderBy, IEnumerable <Expression>?groupBy, SelectOptions options)
: base(DbExpressionType.Select, alias)
{
this.IsDistinct = distinct;
this.SelectOptions = options;
this.Top = top;
this.Columns = columns.ToReadOnly();
this.From = from;
this.Where = where;
this.OrderBy = orderBy.ToReadOnly();
this.GroupBy = groupBy.ToReadOnly();
this.knownAliases = from == null ? new[] { alias } : from.KnownAliases.And(alias).ToArray();
}
protected override async Task <GameData> DrawScenario(GameData data)
{
var matches = await CreateMatchRegistryGrain(data.ClusterClientOption).GetMatches();
SelectOptions options = matches.ToList();
var option = GetFromSelectBox(" Match number: ", options);
if (option == 0)
{
return(data.SetGameMenuItem(MainMenu));
}
var matchGrain = await CreateMatchGrain(data.ClusterClientOption, options[option]);
return(data.SetMatch(Some(matchGrain)));
}
public async Task <IHttpActionResult> GetListAsync([FromUri] MatchStatus?status = null, [FromUri] int page = 0, [FromUri] int size = 10)
{
IMatchRepository repo = UnitOfWork.GetMatchRepository();
SelectOptions <DAL.Models.Match> options = new SelectOptions <DAL.Models.Match>
{
OrderBy = p => p.OrderByDescending(t => t.Id),
Take = size,
Skip = page * size
};
StatusSpecification specification = new StatusSpecification(status);
IEnumerable <DAL.Models.Match> result = await repo.SelectAsync(specification = specification, options : options);
int count = await repo.CountAsync(specification : specification);
Paging paging = new Paging(count: count, page: page, size: size);
GetListResponse response = new GetListResponse(paging)
{
Items = result.Select(m => new GetListResponseItem
{
Id = m.Id,
StartDt = m.StartDt,
Status = m.Status,
Guest = new GetListResponseItemTeam
{
Id = m.GuestId,
City = m.Guest.City,
Country = m.Guest.County,
Goals = m.Goals.Count(g => g.TeamId == m.GuestId),
Name = m.Guest.Name,
Logotype = m.Guest.Logotype
},
Home = new GetListResponseItemTeam
{
Id = m.HomeId,
City = m.Home.City,
Country = m.Home.County,
Goals = m.Goals.Count(g => g.TeamId == m.HomeId),
Name = m.Home.Name,
Logotype = m.Home.Logotype
}
})
};
return(Ok(response));
}
protected IEnumerable <string> GetTagOptions()
{
if (SelectMode == SelectMode.Tags && SelectedValues.HasValue)
{
var optionValues = SelectOptions.Select(option => option.Value).ToHashSet();
if (LabelInValue)
{
var values = SelectedValues.Value.AsT3.ToList();
return(values.Where(v => !optionValues.Contains(v.Key)).Select(v => v.Key));
}
else
{
var values = SelectedValues.Value.AsT1.ToList();
return(values.Where(v => !optionValues.Contains(v)));
}
}
return(Array.Empty <string>());
}
public JsonResult DeleteFile(string file)
{
SelectOptions select = new SelectOptions();
foreach (var item in file_namelist)
{
if (item.Text.Equals(file))
{
file_namelist.Remove(item);
break;
}
}
select.Text = file;
filesHelper.DeleteFile(file);
return(Json("OK", JsonRequestBehavior.AllowGet));
}
private bool SelectItem(Keys Key, bool SingleClick, bool DoubleClick)
{
// Warning!!! Optional parameters not supported
// Warning!!! Optional parameters not supported
// Warning!!! Optional parameters not supported
bool DoSelect = true;
SelectOptions Meth = SelectOptions.None;
LastItem = -1;
if (((this.mySelectionMethods & SelectOptions.OnEnterPress) > 0) && (Key == Keys.Enter))
{
Meth = SelectOptions.OnEnterPress;
}
else if (((this.mySelectionMethods & SelectOptions.OnRightArrow) > 0) && Key == Keys.Right)
{
Meth = SelectOptions.OnRightArrow;
}
else if (((this.mySelectionMethods & SelectOptions.OnTabPress) > 0) && Key == Keys.Tab)
{
Meth = SelectOptions.OnTabPress;
}
else if (((this.mySelectionMethods & SelectOptions.OnSingleClick) > 0) && SingleClick)
{
Meth = SelectOptions.OnEnterPress;
}
else if (((this.mySelectionMethods & SelectOptions.OnDoubleClick) > 0) && DoubleClick)
{
Meth = SelectOptions.OnEnterPress;
}
else
{
DoSelect = false;
}
LastItem = LBoxEx.SelectedIndex;
if (DoSelect)
{
DoSelectItem(Meth);
}
return(DoSelect);
}
private void DoSelectItem(SelectOptions Method)
{
if (((this.LBoxEx.Items.Count > 0) &&
(this.LBoxEx.SelectedIndex > -1)))
{
string Value = this.LBoxEx.SelectedItem.ToString();
string Orig = this.Text;
getSelection = true;
this.Text = Value;
if (mySelectTextAfterItemSelect)
{
try
{
this.SelectionStart = Orig.Length;
this.SelectionLength = (Value.Length - Orig.Length);
}
catch
{
}
}
else
{
// Me.SelectionStart = Me.Text.Length
// Me.SelectionLength = 0
}
TextBoxExItemSelectedEventArgs a;
a = new TextBoxExItemSelectedEventArgs();
a.Index = this.LBoxEx.SelectedIndex;
a.Method = Method;
a.ItemText = Value;
if (ItemSelected != null)
{
ItemSelected(this, a);
}
//ItemSelected(this, new clsItemSelectedEventArgs(this.myLbox.SelectedIndex, Method, Value));
this.DoHideAuto();
}
}
private void btnSelect_Click(object sender, EventArgs e)
{
string selectClause = this.txtSelect.Text;
string sortClause = "";
string dictClause = "";
string preSelectClause = "";
bool calculated = true;
bool conversion = false;
bool formatSpec = false;
bool originalBuffer = true;
bool onlyitemid = false;
bool pagination = false;
int regPage = 10;
int numPag = 1;
SelectOptions selectOptions = new SelectOptions(onlyitemid, pagination, regPage, numPag, calculated, conversion, formatSpec, originalBuffer);
string customVars = "";
string error;
//DateTime dtantes = DateTime.Now;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
try
{
List <Customer> lstCustomers = this._LinkarClt.Select <Customer>(filename, selectClause, sortClause, dictClause, preSelectClause, selectOptions, customVars);
if (lstCustomers != null)
{
cLkCustomersBindingSource.DataSource = lstCustomers;
}
}
catch (Exception ex)
{
string msgErr = FormDemo.GetExceptionInfo(ex);
MessageBox.Show(this, msgErr, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//DateTime dtdespues = DateTime.Now;
//TimeSpan ts = dtdespues - dtantes;
//MessageBox.Show(ts.Minutes + " - " + ts.Seconds + " - " + ts.Milliseconds);
}
/// <summary>
/// Compose the 3 items (CUSTOMVARS, OPTIONS and INPUTDATA) of the Select operation.
/// </summary>
/// <param name="filename">Name of file on which the operation is performed. For example LK.ORDERS</param>
/// <param name="selectClause">Statement fragment specifies the selection condition. For example WITH CUSTOMER = '1'</param>
/// <param name="sortClause">Statement fragment specifies the selection order. If there is a selection rule, Linkar will execute a SSELECT, otherwise Linkar will execute a SELECT. For example BY CUSTOMER</param>
/// <param name="dictClause">Space-delimited list of dictionaries to read. If this list is not set, all fields are returned. For example CUSTOMER DATE ITEM</param>
/// <param name="preSelectClause">An optional command that executes before the main Select</param>
/// <param name="selectOptions">Object with options to manage how records are selected, including calculated, dictionaries, conversion, formatSpec, originalRecords, onlyItemId, pagination, regPage, numPage.</param>
/// <param name="customVars">Free text sent to the database allows management of additional behaviours in SUB.LK.MAIN.CONTROL.CUSTOM, which is called when this parameter is set.</param>
/// <returns>A string ready to be used in Linkar.ExecuteDirectOperation and Linkar.ExecutePersistentOperation.</returns>
public static string GetSelectArgs(string filename, string selectClause, string sortClause, string dictClause, string preSelectClause,
SelectOptions selectOptions, string customVars)
{
if (selectOptions == null)
{
selectOptions = new SelectOptions();
}
string options = selectOptions.ToString();
string inputData = filename + DBMV_Mark.AM +
selectClause + DBMV_Mark.AM +
sortClause + DBMV_Mark.AM +
dictClause + DBMV_Mark.AM +
preSelectClause;
string cmdArgs = customVars + ASCII_Chars.US_str + options + ASCII_Chars.US_str + inputData;
return(cmdArgs);
}
public async Task <IHttpActionResult> GetListAsync([FromUri] int page = 0, [FromUri] int size = 10, [FromUri] string searchString = null)
{
SelectOptions <Post> options = new SelectOptions <Post>
{
OrderBy = p => p.OrderByDescending(t => t.Id),
Take = size,
Skip = page * size
};
options.Includes.Add(p => p.Dislikes);
options.Includes.Add(p => p.Likes);
IPostRepository repo = UnitOfWork.GetPostRepository();
ISpecification <Post> specification = (new TitleSpecification(searchString)
.Or(new ContentSpecification(searchString)))
.And(new StatusSpecification(Enums.PostStatus.Published));
IEnumerable <Post> list = await repo.SelectAsync(options : options, specification : specification);
int resultsCount = await repo.CountAsync(specification : specification);
Paging paging = new Paging(page: page, count: resultsCount, size: size);
GetListResponse response = new GetListResponse(paging)
{
Items = list.Select(p => new GetListReponseItem
{
Id = p.Id,
Image = p.Items.FirstOrDefault(i => i.Type == Enums.PostItemType.Image).Guid,
Intro = p.Items.FirstOrDefault(i => i.Type == Enums.PostItemType.Text).Text,
Title = p.Title,
Likes = p.Likes.Count,
Dislikes = p.Dislikes.Count
})
};
return(Ok(response));
}
public async Task <T[]> Select <T>(object key, SelectOptions selectOptions)
where T : class
{
selectOptions = selectOptions ?? new SelectOptions();
if (key == null)
{
var props = TarantoolHelper.GetProperties(typeof(T));
var indexType = props[0].PropertyType;
if (TarantoolHelper.IsNumericType(indexType))
{
key = -1L;
}
else
{
key = String.Empty;
}
selectOptions.Iterator = Iterator.All;
}
var keyTuple = key as ITarantoolTuple;
if (keyTuple == null)
{
var keyType = key.GetType();
var tupleType = typeof(TarantoolTuple <>).MakeGenericType(new[] { keyType });
keyTuple = (ITarantoolTuple)Activator.CreateInstance(tupleType, new object[] { key });
}
var index = await GetIndex();
var retValue = await TarantoolHelper.Select <T>(index, keyTuple, selectOptions);
return(retValue);
}
private void DoSelectItem(SelectOptions method)
{
System.Diagnostics.Debug.WriteLine("At position: {0}", listBox.SelectedIndex);
if (((listBox.Items.Count > 0) && (listBox.SelectedIndex > -1)))
{
string value = listBox.SelectedItem.ToString();
string orig = Text;
Text = value;
if (mySelectTextAfterItemSelect)
{
try
{
SelectionStart = orig.Length;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
var itemSelectedEventArgs = new ItemSelectedEventArgs
{
Index = listBox.SelectedIndex,
Method = method,
ItemText = value
};
if (ItemSelected != null)
{
ItemSelected(this, itemSelectedEventArgs);
}
//ItemSelected(this, new clsItemSelectedEventArgs(myLbox.SelectedIndex, Method, Value));
DoHideAuto();
}
}
private void addB_Click(object sender, EventArgs e)
{
DataRow[] rows = crops.Select(String.Format("name = '{0}'", cropsCB.Text));
if (rows.Length == 0)
{
form.backSlide(form.farmvilleSlide);
}
DataRow row = rows[0];
SelectOptions options = new SelectOptions();
options.where = String.Format("id = {0}", row["id"]);
options.limit = 1;
DataTable matching = form.db.selectColumns("farmville_crops", new string[] { "name", "cost", "sells", "xp", "harvest" }, options);
DataRow crop = matching.Rows[0];
string crop_name = Convert.ToString(crop["name"]);
int quantity = Convert.ToInt32(quantityCB.Text);
int cost = quantity * Convert.ToInt32(crop["cost"]);
int sells = quantity * Convert.ToInt32(crop["sells"]);
int profit = sells - cost;
int xp = quantity * Convert.ToInt32(crop["xp"]);
int harvest_time = Convert.ToInt32(crop["harvest"]);
DateTime now = DateTime.Now;
DateTime harvest = now.AddMinutes(harvest_time);
DateTime wilts = now.AddMinutes(harvest_time * 2);
List<string> fields = new List<string>();
fields.AddRange(new string[] { "crop_name", "quantity", "cost", "profit", "xp", "harvest", "wilts" });
List<object> values = new List<object>();
values.AddRange(new object[] { crop_name, quantity, cost, profit, xp, harvest, wilts });
form.db.insert("farmville_plots", fields, values);
//Close();
}
public static async Task <T[]> Select <T>(IIndex index,
object key, SelectOptions selectOptions = null)
where T : class
{
if (selectOptions == null)
{
selectOptions = new SelectOptions {
Iterator = Iterator.All
};
}
var props = GetProperties(typeof(T));
var tupleType = GetTarantoolTupleType(props);
var method = index.GetType().GetMethod("Select");
var genericMethod = method.MakeGenericMethod(new Type[] {
key.GetType(), tupleType
});
var task = genericMethod.Invoke(index, new object[] { key, selectOptions }) as Task;
var retValue = await ConvertResult <T>(task, tupleType, props);
return(retValue.ToArray());
}
/// <summary>
/// Executes the select and returns the list of rows
/// </summary>
/// <param name="sql">The SQL.</param>
/// <param name="selectOptions">The select options.</param>
/// <returns>The list of rows</returns>
public IList<ISqlResult> ExecuteQuery(string sql, SelectOptions selectOptions)
{
if (SelectOptions.Single == selectOptions)
return ExecuteSingleSelect(sql);
return ExecuteMultiSelect(sql);
}
public clsItemSelectedEventArgs(int Index, SelectOptions Method, string ItemText)
{
myIndex = Index;
myMethod = Method;
myItemText = ItemText;
}
public static IList<ISqlResult> Select(string sql, SelectOptions options)
{
return provider.ExecuteQuery(sql, options);
}
public ItemSelectedEventArgs(int index, SelectOptions method, string itemText)
{
Index = index;
Method = method;
ItemText = itemText;
}
private void DoSelectItem(SelectOptions method)
{
System.Diagnostics.Debug.WriteLine("At position: {0}", listBox.SelectedIndex);
if (((listBox.Items.Count > 0) && (listBox.SelectedIndex > -1)))
{
string value = listBox.SelectedItem.ToString();
string orig = Text;
Text = value;
if (mySelectTextAfterItemSelect)
{
try
{
SelectionStart = orig.Length;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
var itemSelectedEventArgs = new ItemSelectedEventArgs
{
Index = listBox.SelectedIndex,
Method = method,
ItemText = value
};
if (ItemSelected != null) ItemSelected(this, itemSelectedEventArgs);
//ItemSelected(this, new clsItemSelectedEventArgs(myLbox.SelectedIndex, Method, Value));
DoHideAuto();
}
}
