public async Task NoAccessSelectTest()
{
var reqeust = new SqlessEditRequest()
{
Table = Tables.User,
Fields = new List <SqlessEditField>()
{
new SqlessEditField()
{
Field = "Password",
Value = "1",
Type = System.Data.DbType.String
}
}
};
using Sqless sqless = new Sqless(Global.GetOwnerAccessConfig("1"));
try
{
var result = await sqless.Update(reqeust);
}
catch (UnauthorizedAccessException)
{
Assert.IsTrue(true);
return;
}
Assert.IsTrue(false);
}
public async Task UpsertInsertTest()
{
var newUid = "UpsertTest_" + Guid.NewGuid().ToString();
var request = new SqlessEditRequest()
{
Table = Tables.User,
Queries = new List <Query.SqlessQuery>()
{
new Query.SqlessQuery()
{
Field = "Uid",
Value = newUid,
Type = Query.SqlessQueryType.Equal
}
}
};
request.LoadFromObject(new
{
Uid = newUid,
Name = DateTime.Now.ToString("hhmmss"),
Password = new Random().Next(100000, 999999).ToString()
});
using Sqless sqless = new Sqless(Global.AllowUnspecifiedConfig);
var result = await sqless.Upsert(request);
Assert.IsTrue(result > 0);
}
private async Task <string> CreateOrder(Product product)
{
var order = new Order()
{
Id = Guid.NewGuid().ToString(),
ProductId = product.Id,
Status = 1,
Time = DateTimeOffset.Now.ToUnixTimeSeconds(),
};
var request = new SqlessEditRequest()
{
Table = Tables.Order,
AccessParams = new string[] { User.Uid, User.Password },
};
request.LoadFromObject(order);
try
{
await SqlessClient.Insert(request);
return(order.Id);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(null);
}
}
public async Task <int> Update(SqlessEditRequest request)
{
await OpenSqlConnection();
SqlessUpdateSqlBuilder producer = new SqlessUpdateSqlBuilder(this, request);
return(await producer.ExecuteNonQueryAsync());
}
public void LoadEditRequestFromObjectTest()
{
var obj = new
{
Test1 = "111",
Test2 = "222"
};
var request = new SqlessEditRequest();
request.LoadFromObject(obj);
Assert.IsTrue(request.Fields.Count > 0);
Assert.AreEqual(request.Fields[0].Field, nameof(obj.Test1));;
Assert.AreEqual(request.Fields[0].Value, obj.Test1);
}
public async Task <int> Upsert(SqlessEditRequest request)
{
using var sqless = new Sqless(SqlessConfig.GetAllowUnspecifiedConfig(this.SqlessConfig.SqlConStr));
var count = await sqless.Count(new SqlessCountRequest()
{
Table = request.Table,
Queries = request.Queries.Select(q => q.DeepClone()).ToList(),
});
if (count > 0)
{
return(await Update(request));
}
else
{
return(await Insert(request));
}
}
public async Task InsertTest2()
{
var request = new SqlessEditRequest()
{
Table = Tables.Product
};
request.LoadFromObject(new Product()
{
Id = Guid.NewGuid().ToString(),
Name = new Random().Next(100000, 999999).ToString(),
Price = new Random().Next(1, 100)
});
using Sqless sqless = new Sqless(Global.AllowUnspecifiedConfig);
var result = await sqless.Insert(request);
Assert.IsTrue(result > 0);
}
public async Task UpdateOwnerField1Test()
{
var request = new SqlessEditRequest()
{
Table = Tables.User,
Fields = new List <SqlessEditField>()
{
new SqlessEditField()
{
Field = "Name",
Value = "1",
Type = System.Data.DbType.String
}
}
};
using Sqless sqless = new Sqless(Global.GetOwnerAccessConfig("1"));
var result = await sqless.Update(request);
Assert.IsTrue(result > 0);
}
public async Task InsertTest3()
{
var request = new SqlessEditRequest()
{
Table = Tables.Order
};
request.LoadFromObject(new Order()
{
Id = Guid.NewGuid().ToString(),
ProductId = new Random().Next(1, 4).ToString(),
Uid = new Random().Next(1, 5).ToString(),
Status = 1,
Time = DateTimeOffset.Now.ToUnixTimeSeconds()
});
using Sqless sqless = new Sqless(Global.AllowUnspecifiedConfig);
var result = await sqless.Insert(request);
Assert.IsTrue(result > 0);
}
private async Task <string> Insert()
{
var id = "DeleteTest_" + Guid.NewGuid().ToString("D");
var request = new SqlessEditRequest()
{
Table = Tables.User
};
request.LoadFromObject(new User
{
Uid = id,
Name = DateTime.Now.ToString("hhmmss"),
Password = new Random().Next(100000, 999999).ToString()
});
using Sqless sqless = new Sqless(Global.AllowUnspecifiedConfig);
var result = await sqless.Insert(request);
Assert.IsTrue(result > 0);
return(id);
}
public async Task UpdateOwnerFieldSqlTest()
{
var insertRequest = new SqlessEditRequest()
{
Table = Tables.User,
Fields = new List <SqlessEditField>()
{
new SqlessEditField()
{
Field = "Uid",
Value = "2",
Type = System.Data.DbType.String
}
}
};
using Sqless insertSqless = new Sqless(Global.GetOwnerAccessConfig("1"));
SqlessInsertSqlBuilder producer = new SqlessInsertSqlBuilder(insertSqless, insertRequest);
var sqlStr = await producer.GetSqlStrTest();
Assert.AreEqual(insertRequest.Fields[0].Value, "1");
}
public async Task UpdateOwnerFieldTest()
{
var updateRequest = new SqlessEditRequest()
{
Table = Tables.User,
Fields = new List <SqlessEditField>()
{
new SqlessEditField()
{
Field = "Uid",
Value = "2",
Type = System.Data.DbType.String
}
}
};
using Sqless updateSqless = new Sqless(Global.GetOwnerAccessConfig("1"));
var updateResult = await updateSqless.Update(updateRequest);
Assert.IsTrue(updateResult > 0);
var selectRequest = new SqlessSelectRequest()
{
Table = Tables.User,
Fields = new List <Query.SqlessField>()
{
new SqlessField()
{
Field = "Uid"
}
}
};
using Sqless selectSqless = new Sqless(Global.GetOwnerAccessConfig("1"));
var selectResult = await selectSqless.SelectFirstOrDefault <string>(selectRequest);
Assert.AreEqual(selectResult, "1");
}
private async Task <bool> Payment(string orderId)
{
var request = new SqlessEditRequest()
{
Table = Tables.Order,
AccessParams = new string[] { User.Uid, User.Password },
Fields = new System.Collections.Generic.List <SqlessEditField>()
{
new SqlessEditField()
{
Field = nameof(Order.Status),
Value = 2,
Type = System.Data.DbType.Int32
}
},
Queries = new System.Collections.Generic.List <SqlessQuery>()
{
new SqlessQuery()
{
Field = nameof(Product.Id),
Type = SqlessQueryType.Equal,
Value = orderId
}
}
};
try
{
await SqlessClient.Update(request);
return(true);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
}
public async Task InsertTest()
{
var order = new Order()
{
Id = Guid.NewGuid().ToString(),
ProductId = "1",
Status = 1,
Time = DateTimeOffset.Now.ToUnixTimeSeconds(),
};
var request = new SqlessEditRequest()
{
Table = Tables.Order,
AccessParams = new string[] { "AccessTestUid", "123456" },
};
request.LoadFromObject(order);
var uid = await Global.PasswordAccessConfig.GetUid(request.AccessParams);
using Sqless sqless = new Sqless(Global.GetOwnerAccessConfig(uid));
var result = await sqless.Insert(request);
Assert.IsTrue(result > 0);
}
public static async Task <int> Upsert(SqlessEditRequest request) => await Post <int>(request, SqlessApiType.Upsert);
public virtual async Task <ActionResult> Upsert(SqlessEditRequest request)
{
using Sqless sqless = await GetSqless(request);
return(Ok(await sqless.Upsert(request)));
}
public SqlessUpdateSqlBuilder(Sqless sqless, SqlessEditRequest request)
: base(sqless, request)
{
}
