public static List <UserAccess> GetAll()
{
List <UserAccess> userAccessList = new List <UserAccess>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetUserAccessCommand objectCommand = new GetUserAccessCommand(objectConnection))
{
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(userAccessList);
}
using (UserAccessSqlDataReader objectSqlDataReader = new UserAccessSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
UserAccess userAccess = objectSqlDataReader.UserAccess;
userAccessList.Add(userAccess);
}
}
}
}
}
return(userAccessList);
}
public static List <Order> GetOrderByLastName(string lastName)
{
List <Order> orderList = new List <Order>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetOrderByLastName objectCommand = new GetOrderByLastName(objectConnection))
{
objectCommand.LastName = lastName;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(orderList);
}
using (OrderSqlDataReader objectSqlDataReader = new OrderSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Order order = objectSqlDataReader.Order;
orderList.Add(order);
}
}
}
}
}
return(orderList);
}
public static List <Order> GetByInventoryItemId(Guid inventoryItemId)
{
List <Order> orderList = new List <Order>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetOrderByInventoryItemId objectCommand = new GetOrderByInventoryItemId(objectConnection))
{
objectCommand.InventoryItemId = inventoryItemId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(orderList);
}
using (OrderSqlDataReader objectSqlDataReader = new OrderSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Order order = objectSqlDataReader.Order;
orderList.Add(order);
}
}
}
}
}
return(orderList);
}
public static List <Customer> GetCustomerByPersonEmail(string personEmail)
{
List <Customer> customerList = new List <Customer>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetCustomerByPersonEmailCommand objectCommand = new GetCustomerByPersonEmailCommand(objectConnection))
{
objectCommand.PersonEmail = personEmail;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(customerList);
}
using (CustomerSqlDataReader objectSqlDataReader = new CustomerSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Customer customer = objectSqlDataReader.Customer;
customerList.Add(customer);
}
}
}
}
}
return(customerList);
}
public static Person GetByPersonId(Guid personId)
{
Person person = new Person();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetPersonByPersonIdCommand objectCommand = new GetPersonByPersonIdCommand(objectConnection))
{
objectCommand.PersonId = personId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(person);
}
using (PersonSqlDataReader objectSqlDataReader = new PersonSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
person = objectSqlDataReader.Person;
}
}
}
}
}
return(person);
}
public static List <Notification> GetByJobRole(string permissionEnum)
{
List <Notification> notificationList = new List <Notification>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetNotificationByJobRoleCommand objectCommand = new GetNotificationByJobRoleCommand(objectConnection))
{
objectCommand.PermissionEnum = permissionEnum;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(notificationList);
}
using (NotificationSqlDataReader objectSqlDataReader = new NotificationSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Notification notification = objectSqlDataReader.Notification;
notificationList.Add(notification);
}
}
}
}
}
return(notificationList);
}
public static List <Address> GetAddressByPersonId(Guid personId)
{
List <Address> addressList = new List <Address>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetAddressByPersonIdCommand objectCommand = new GetAddressByPersonIdCommand(objectConnection))
{
objectCommand.PersonId = personId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(addressList);
}
using (AddressSqlDataReader objectSqlDataReader = new AddressSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Address address = objectSqlDataReader.Address;
addressList.Add(address);
}
}
}
}
}
return(addressList);
}
public static List <OrderItem> GetByOrderId(Guid orderId)
{
List <OrderItem> orderItemList = new List <OrderItem>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetOrderItemByOrderIdCommand objectCommand = new GetOrderItemByOrderIdCommand(objectConnection))
{
objectCommand.OrderId = orderId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(orderItemList);
}
using (OrderItemSqlDataReader objectSqlDataReader = new OrderItemSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
OrderItem orderItem = objectSqlDataReader.OrderItem;
orderItemList.Add(orderItem);
}
}
}
}
}
return(orderItemList);
}
public static UserAccess GetByUserName(string userName)
{
UserAccess userAccess = new UserAccess();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetUserAccessByUserNameCommand objectCommand = new GetUserAccessByUserNameCommand(objectConnection))
{
objectCommand.UserName = userName;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(null);
}
using (UserAccessSqlDataReader objectSqlDataReader = new UserAccessSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
userAccess = objectSqlDataReader.UserAccess;
}
}
}
}
}
return(userAccess);
}
public static List <InventoryItem> GetByInventoryItemIdAndInventoryItemStatusId(Guid inventoryItemId, int inventoryItemStatusId)
{
List <InventoryItem> inventoryItemList = new List <InventoryItem>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetInventoryItemByInventoryItemIdAndInventoryItemStatusIdCommand objectCommand = new GetInventoryItemByInventoryItemIdAndInventoryItemStatusIdCommand(objectConnection))
{
objectCommand.InventoryItemId = inventoryItemId;
objectCommand.InventoryItemStatusId = inventoryItemStatusId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(inventoryItemList);
}
using (InventoryItemSqlDataReader objectSqlDataReader = new InventoryItemSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
InventoryItem inventoryItem = objectSqlDataReader.InventoryItem;
inventoryItemList.Add(inventoryItem);
}
}
}
}
}
return(inventoryItemList);
}
public static CatalogItem GetByItemName(string itemName)
{
CatalogItem catalogItem = new CatalogItem();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetCatalogItemByItemNameCommand objectCommand = new GetCatalogItemByItemNameCommand(objectConnection))
{
objectCommand.ItemName = itemName;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(catalogItem);
}
using (CatalogItemSqlDataReader objectSqlDataReader = new CatalogItemSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
catalogItem = objectSqlDataReader.CatalogItem;
}
}
}
}
}
return(catalogItem);
}
public static Customer GetCustomerByPersonId(Guid personId)
{
Customer customer = new Customer();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetCustomerByPersonIdCommand objectCommand = new GetCustomerByPersonIdCommand(objectConnection))
{
objectCommand.PersonId = personId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(customer);
}
using (CustomerSqlDataReader objectSqlDataReader = new CustomerSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
customer = objectSqlDataReader.Customer;
}
}
}
}
}
return(customer);
}
protected sealed override async Task Act(IFlowContext context, ObjectConnection <NuxeoConfig> connection, T?arguments)
{
var config = connection.Object;
using var client = new Client(config.Url, new(config.Username, config.Password));
await Act(context, arguments, client);
}
public static List <CatalogItem> GetByManufacturer(string manufacturer)
{
List <CatalogItem> catalogItemList = new List <CatalogItem>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetCatalogItemByManufacturerCommand objectCommand = new GetCatalogItemByManufacturerCommand(objectConnection))
{
objectCommand.Manufacturer = manufacturer;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(catalogItemList);
}
using (CatalogItemSqlDataReader objectSqlDataReader = new CatalogItemSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
catalogItemList.Add(objectSqlDataReader.CatalogItem);
}
}
}
}
}
return(catalogItemList);
}
public static List <Notification> GetByNotificationId(Guid notificationId)
{
List <Notification> notificationList = new List <Notification>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetNotificationByNotificationIdCommand objectCommand = new GetNotificationByNotificationIdCommand(objectConnection))
{
objectCommand.NotificationId = notificationId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(notificationList);
}
using (NotificationSqlDataReader objectSqlDataReader = new NotificationSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Notification notification = objectSqlDataReader.Notification;
notificationList.Add(notification);
}
}
}
}
}
return(notificationList);
}
//Special code for singe record return only. Do not copy and paste for typical queries.
public static int GetNumberInStock(Guid catalogItemId)
{
int numberInStock = 0;
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetCatalogItemStockCountCommand objectCommand = new GetCatalogItemStockCountCommand(objectConnection))
{
objectCommand.CatalogItemId = catalogItemId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(numberInStock);
}
using (CatalogItemStockCountSqlDataReader objectSqlDataReader = new CatalogItemStockCountSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
numberInStock = objectSqlDataReader.NumberInStock;
}
}
}
}
}
return(numberInStock);
}
public static List <Person> GetByUserId(Guid userId)
{
List <Person> personList = new List <Person>();
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (GetPersonByUserIdCommand objectCommand = new GetPersonByUserIdCommand(objectConnection))
{
objectCommand.UserId = userId;
objectConnection.Open();
using (SqlDataReader sqlDataReader = objectCommand.ExecuteReader())
{
if (!sqlDataReader.HasRows)
{
return(personList);
}
using (PersonSqlDataReader objectSqlDataReader = new PersonSqlDataReader(sqlDataReader))
{
while (objectSqlDataReader.Read())
{
Person person = objectSqlDataReader.Person;
personList.Add(person);
}
}
}
}
}
return(personList);
}
protected sealed override async Task Act(IFlowContext context, ObjectConnection <ImapConfiguration> connection, TArguments?arguments)
{
var config = connection.Object;
using var client = new ImapClient();
await client.ConnectAsync(config.Host, config.Port);
await client.AuthenticateAsync(config.Username, config.Password);
await Act(context, client, arguments ?? new TArguments());
}
protected override async Task Act(IFlowContext context, ObjectConnection <Client> connection, RemoveArguments?arguments)
{
if (arguments is null)
{
throw new ArgumentNullException(nameof(arguments));
}
var ids = await arguments.Ids.Resolve(context);
var deleteData = await arguments.DeleteData.Resolve(context);
connection.Object.TorrentRemoveAsync(ids, deleteData);
}
protected override async Task Act(IFlowContext context, ObjectConnection <Client> connection, ParameterizedNewTorrent?arguments)
{
if (arguments is null)
{
throw new ArgumentNullException(nameof(arguments));
}
var newTorrent = await arguments.Resolve(context);
var torrentInfo = await connection.Object.TorrentAddAsync(newTorrent).ConfigureAwait(false);
await context.SetData(torrentInfo);
}
public static int Delete(UserAccess user)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (DeleteUserAccessByUsernameCommand objectCommand = new DeleteUserAccessByUsernameCommand(objectConnection))
{
objectCommand.Username = user.UserName;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
public static int DeleteNotification(Guid notificationId)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (DeleteNotificationByNotificationIdCommand objectCommand = new DeleteNotificationByNotificationIdCommand(objectConnection))
{
objectCommand.NotificationId = notificationId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
protected override IConnection CreateConnection(TransmissionConfiguration configuration)
{
if (configuration.Endpoint is null)
{
throw new ArgumentNullException(nameof(configuration.Endpoint));
}
var client = new Client(
configuration.Endpoint.ToString(),
login: configuration.Login,
password: configuration.Password
);
return(ObjectConnection.From(client));
}
protected override async Task Act(IFlowContext context, ObjectConnection <Client> connection, GetArguments?arguments)
{
if (arguments is null)
{
throw new ArgumentNullException(nameof(arguments));
}
var fields = await arguments.Fields.Resolve(context);
var ids = await arguments.Ids.Resolve(context);
var torrents = await connection.Object.TorrentGetAsync(fields, ids);
await context.SetData(torrents);
}
public static int Delete(InventoryItem inventoryItem)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (DeleteInventoryItemByInventoryItemIdCommand objectCommand = new DeleteInventoryItemByInventoryItemIdCommand(objectConnection))
{
objectCommand.InventoryItemId = inventoryItem.InventoryItemId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
public static int InsertCustomer(Guid customerId, Guid personId)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (InsertCustomerCommand objectCommand = new InsertCustomerCommand(objectConnection))
{
objectCommand.CustomerId = customerId;
objectCommand.PersonId = personId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
public static int Insert(InventoryItem inventoryItem)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (InsertInventoryItemCommand objectCommand = new InsertInventoryItemCommand(objectConnection))
{
objectCommand.InventoryItemId = (inventoryItem.InventoryItemId != Guid.Empty) ? inventoryItem.InventoryItemId : new Guid();
objectCommand.CatalogItemId = inventoryItem.CatalogItemId;
objectCommand.OrderId = inventoryItem.OrderId;
objectCommand.InventoryItemStatusId = inventoryItem.InventoryItemStatusId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
public static int Insert(Guid?inventoryItemId, Guid catalogItemId, Guid?orderId, int inventoryItemStatusId)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (InsertInventoryItemCommand objectCommand = new InsertInventoryItemCommand(objectConnection))
{
objectCommand.InventoryItemId = inventoryItemId ?? new Guid();
objectCommand.CatalogItemId = catalogItemId;
objectCommand.OrderId = orderId;
objectCommand.InventoryItemStatusId = inventoryItemStatusId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
public static int UpdateByUserId(Guid userId, string userName, string userPassword, Guid personId)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (UpdateUserAccessByUserIdCommand objectCommand = new UpdateUserAccessByUserIdCommand(objectConnection))
{
objectCommand.UserId = userId;
objectCommand.UserName = userName;
objectCommand.UserPassword = userPassword;
objectCommand.PersonId = personId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
public static int UpdateByInventoryItemId(InventoryItem inventoryItem)
{
using (ObjectConnection objectConnection = new ObjectConnection())
{
using (UpdateInventoryItemByInventoryItemIdCommand objectCommand = new UpdateInventoryItemByInventoryItemIdCommand(objectConnection))
{
objectCommand.InventoryItemId = inventoryItem.InventoryItemId;
objectCommand.OrderId = inventoryItem.OrderId;
objectCommand.CatalogItemId = inventoryItem.CatalogItemId;
objectCommand.InventoryItemStatusId = inventoryItem.InventoryItemStatusId;
objectConnection.Open();
objectCommand.ExecuteNonQuery();
return(objectCommand.ReturnValue);
}
}
}
