text stringlengths 13 6.01M |
|---|
using Alabo.Domains.Dtos;
using Alabo.Domains.Entities;
using Alabo.Validations.Aspects;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace Alabo.Domains.Services.Bulk {
/// <summary>
/// 批量保存操作
/// </summary>
public interface IBulkAsync<TEntity, in TKey> where TEntity : class, IAggregateRoot<TEntity, TKey> {
/// <summary>
/// 批量保存
/// </summary>
/// <param name="addList">新增列表</param>
/// <param name="updateList">修改列表</param>
/// <param name="deleteList">删除列表</param>
Task<List<TDto>> SaveAsync<TDto, TRequest>(List<TRequest> addList, List<TRequest> updateList,
List<TRequest> deleteList)
where TRequest : IRequest, IKey, new()
where TDto : IResponse, new();
/// <summary>
/// 修改实体
/// </summary>
/// <param name="entities">实体集合</param>
Task UpdateAsync([Valid] IEnumerable<TEntity> entities);
Task AddManyAsync(IEnumerable<TEntity> soucre);
/// <summary>
/// 批量更新多个实体
/// </summary>
/// <param name="updateAction"></param>
/// <param name="predicate">查询条件</param>
void UpdateManyAsync(Action<TEntity> updateAction, Expression<Func<TEntity, bool>> predicate = null);
/// <summary>
/// 添加实体集合
/// </summary>
/// <param name="entities">实体集合</param>
Task AddManyAsyncAsync([Valid] IEnumerable<TEntity> entities);
/// <summary>
/// 添加，更新，或删除
/// 添加：主键Id为0或者为空的商品
/// 编辑：主键Id，在数据库中存在的商品
/// 删除：根据输入条件查找出所有的列表，如果列表不在传入的数据中，则删除
/// </summary>
/// <param name="entities">The entities.</param>
/// <param name="predicate">判断条件</param>
void AddUpdateOrDeleteAsync(IEnumerable<TEntity> entities, Expression<Func<TEntity, bool>> predicate);
}
} |
using System;
using System.Collections.Generic;
using Pe.Stracon.SGC.Infraestructura.Core.Base;
using Pe.Stracon.SGC.Infraestructura.QueryModel.Contractual;
using Pe.Stracon.Politicas.Aplicacion.TransferObject.Response.General;
namespace Pe.Stracon.SGC.Infraestructura.Core.QueryContract.Contractual
{
public interface IContratoLogicRepository : IQueryRepository<ContratoLogic>
{
/// <summary>
/// Metodo para listar los contrato por usuario.
/// </summary>
/// <param name="CodigoResponsable">Codigo de trabajador que consulta</param>
/// <param name="UnidadOperativa">Código de Unidad Operativa</param>
/// <param name="NombreProveedor">Nombre del proveedor</param>
/// <param name="NumdocPrv">Número de documento del proveedor</param>
/// <param name="TipoServicio">Tipo de Servicio</param>
/// <param name="TipoReq">Tipo de Requerimiento</param>
/// <param name="nombreEstadio">Nombre de Estadio</param>
/// <param name="indicadorFinalizarAprobacion">Indicador de Finalizar Aprobación</param>
/// <returns>Lista de bandeja de contratos</returns>
List<ContratoLogic> ListaBandejaContratos(
Guid CodigoResponsable,
Guid? UnidadOperativa,
string NombreProveedor,
string NumdocPrv,
string TipoServicio,
string TipoReq,
string nombreEstadio,
string indicadorFinalizarAprobacion);
/// <summary>
/// Metodo para listar las Observaciones por Contrato por Estadio.
/// </summary>
/// <param name="CodigoContratoEstadio">Código de Contrato Estadio</param>
/// <returns>Lista de bandeja de contratos por observaciones</returns>
List<ContratoEstadioObservacionLogic> ListaBandejaContratosObservacion(Guid CodigoContratoEstadio);
/// <summary>
/// Metodo para listar las Consultas por Contrato por Estadio.
/// </summary>
/// <param name="CodigoContratoEstadio">Código de Contrato Estadio</param>
/// <returns>Lista de consultas por contrato</returns>
List<ContratoEstadioConsultaLogic> ListaBandejaContratosConsultas(Guid CodigoContratoEstadio);
/// <summary>
/// Metodo para aprobar cada contrato según su estadío.
/// </summary>
/// <param name="codigoContratoEstadio">Código de Contrato Estadío</param>
/// <param name="codigoIdentificacionUO">Código de Identificación UO</param>
/// <param name="UserUpdate">Usuario que actualiza</param>
/// <param name="TerminalUpdate">Terminal desde donde se ejecuta.</param>
/// <param name="codigoUsuarioCreacionContrato">Código de Usuario de creación de contrato</param>
/// <param name="MotivoAprobacion"></param>
/// <returns>Lista de estadios aprobados</returns>
int ApruebaContratoEstadio(Guid codigoContratoEstadio, string codigoIdentificacionUO, string UserUpdate, string TerminalUpdate, string codigoUsuarioCreacionContrato, string MotivoAprobacion);
/// <summary>
/// Método para retornar los párrafos por contrato
/// </summary>
/// <param name="CodigoContrato">Código de Contrato</param>
/// <returns>Parrafos por contrato</returns>
List<ContratoParrafoLogic> RetornaParrafosPorContrato(Guid CodigoContrato);
/// <summary>
/// Método que retorna los estadio del contrato para su observación.
/// </summary>
/// <param name="CodigoContratoEstadio">Código del Estadío del Contrato</param>
/// <returns>Estadios de contrato</returns>
List<FlujoAprobacionEstadioLogic> RetornaEstadioContratoObservacion(Guid CodigoContratoEstadio);
/// <summary>
/// Responder la Consulta que me han hecho
/// </summary>
/// <param name="codigoContratoEstadioConsulta"></param>
/// <param name="Respuesta"></param>
/// <param name="UsuarioModificacion"></param>
/// <param name="TerminalModificacion"></param>
/// <returns></returns>
int Responder_Consulta(Guid codigoContratoEstadioConsulta, string Respuesta, string UsuarioModificacion,string TerminalModificacion);
/// <summary>
/// Método para generar un nuevo Estadio de contrato cada vez que es observado.
/// </summary>
/// <param name="codigoContratoEstadioObservado">Código de Contrato Estadio Observado</param>
/// <param name="codigoContrato"> Código de Contrato </param>
/// <param name="codigoFlujoEstadioRetorno">Código Flujo Estadio Retorno </param>
/// <param name="codigoResponsable">Código de Responsable </param>
/// <param name="UserUpdate">Usuario que actualiza</param>
/// <param name="TerminalUpdate">Terminal desde donde de actualiza</param>
/// <returns>Estadios de contrato segun observación</returns>
int ObservaEstadioContrato(Guid codigoContratoEstadio, Guid codigoContratoEstadioObservado, Guid codigoContrato, Guid codigoFlujoEstadioRetorno,
Guid codigoResponsable, string UserUpdate, string TerminalUpdate);
/// <summary>
/// Método que retorna los responsable por flujo de aprobación.
/// </summary>
/// <param name="codigoFlujoAprobacion">código del flujo de aprobación.</param>
/// <param name="codigoContrato"></param>
/// <returns>Responsable del flujo del estadio</returns>
List<TrabajadorResponse> RetornaResponsablesFlujoEstadio(Guid codigoFlujoAprobacion, Guid codigoContrato);
/// <summary>
/// Método para listar los documentos de l bandeja de solicitud.
/// </summary>
/// <param name="NumeroContrato">número del contrato</param>
/// <param name="UnidadOperativa">unidad operativa</param>
/// <param name="NombreProveedor">nombre del proveedor</param>
/// <param name="NumdocPrv">numero documento del proveedor</param>
/// <returns>Documentos de la bandeja de solicitud</returns>
List<ContratoLogic> ListaBandejaSolicitudContratos(string NumeroContrato, Guid? UnidadOperativa, string NombreProveedor, string NumdocPrv);
/// <summary>
/// Método para retornar los documentos PDf por Contrato
/// </summary>
/// <param name="CodigoContrato">Código de Contrato</param>
/// <returns>Documentos pdf por contrato</returns>
List<ContratoDocumentoLogic> DocumentosPorContrato(Guid CodigoContrato);
/// <summary>
/// Metodo para cargar un Archivo a un estadio de contrato.
/// </summary>
/// <param name="objLogic">Objeto Contrato Documento Logic</param>
/// <param name="User">Usuario que ejecuta la transaccion</param>
/// <param name="Terminal">Terminal desde donde se ejecuta la transaccion</param>
/// <returns>Indicador con el resultado de la operación</returns>
int RegistraContratoDocumentoCargaArchivo(ContratoDocumentoLogic objLogic, string User, string Terminal);
/// <summary>
/// Método para retornar registros de Contrato Documento
/// </summary>
/// <param name="CodigoContrato">Llave primaria código contrato</param>
/// <returns>Lista de registros</returns>
List<ContratoDocumentoLogic> ListarContratoDocumento(Guid codigoContrato);
/// <summary>
/// Lista los Estadios de los Contratos
/// </summary>
/// <param name="codigoContratoEstadio">Codigo de Contrato Estadio</param>
/// <param name="codigoContrato">Código de contrato</param>
/// <param name="codigoFlujoAprobEsta">Código de flujo de aprobación</param>
/// <param name="fechaIngreso">Fecha de ingreso</param>
/// <param name="fechaFinaliz">Fecha de finalización</param>
/// <param name="codigoResponsable">Código de responsable</param>
/// <param name="codigoEstadoContratoEst">Código de Estados de Contrato Estadio</param>
/// <param name="fechaPrimera">Fecha de primera notificación</param>
/// <param name="fechaUltima">Fecha de última notificación</param>
/// <param name="PageNumero">número de página</param>
/// <param name="PageSize">tamaño por página</param>
/// <returns>Estadios de los contratos</returns>
List<ContratoEstadioLogic> ListarContratoEstadio(Guid? codigoContratoEstadio = null, Guid? codigoContrato = null,
Guid? codigoFlujoAprobEsta = null, DateTime? fechaIngreso = null,
DateTime? fechaFinaliz = null, Guid? codigoResponsable = null,
string codigoEstadoContratoEst = null,
DateTime? fechaPrimera = null, DateTime? fechaUltima = null,
int PageNumero = 1, int PageSize = -1);
/// <summary>
/// Método para retornar las unidades operativas del responsable.
/// </summary>
/// <param name="codigoTrabajador">Código del Trabjador</param>
/// <returns>Lista de registros</returns>
List<UnidadOperativaLogic> ListarUnidadOperativaResponsable(Guid codigoTrabajador);
/// <summary>
/// Retorna el participante y el codigo del flujo de aprobacion anterior del contrato estadio.
/// </summary>
/// <param name="codigoContratoEstadio">Codigo de Contrato Estadio</param>
/// <param name="codigoContrato">Código de contrato</param>
/// <returns>Participante y el código del flujo de aprobación</returns>
List<FlujoAprobacionParticipanteLogic> EstadoAnteriorContratoEstadio(Guid codigoContratoEstadio, Guid codigoContrato);
/// <summary>
/// Notifica las acciones de contratos.
/// </summary>
/// <param name="asunto">Asunto de la notificación</param>
/// <param name="textoNotificar">contenido de la notificación</param>
/// <param name="cuentaNotificar">cuentas destino a notificar</param>
/// <param name="cuentaCopias">cuentas de copia del correo</param>
/// <param name="profileCorreo">profile de la configuración de correo</param>
/// <returns>Acciones del contrato</returns>
int NotificaBandejaContratos(string asunto, string textoNotificar, string cuentaNotificar, string cuentaCopias, string profileCorreo);
/// <summary>
/// Retorna los parámetros necesarios para enviar la notificación
/// </summary>
/// <param name="codigoContratoEstadio">Código de Contrato estadio</param>
/// <param name="TipoNotificacion">Tipo de notificación</param>
/// <returns>Parametros necesarios para enviar la notifación</returns>
List<ContratoEstadioLogic> InformacionNotificacionContratoEstadio(Guid codigoContratoEstadio, string TipoNotificacion);
/// <summary>
/// Listado de contratos por estadio responsable
/// </summary>
/// <param name="codigoContrato">Código de contrato</param>
/// <returns>Listado de contrato estadio</returns>
List<ContratoEstadioLogic> ListadoContratoEstadioResponsable(Guid codigoContrato);
/// <summary>
/// Registrar adenda con contrato vencido
/// </summary>
/// <param name="unidadOperativa">Código Unidad Operativa</param>
/// <param name="numeroContrato">Número contrato</param>
/// <param name="descripcion">Descripción</param>
/// <param name="numeroAdenda">Número de adenda</param>
/// <param name="numeroAdendaConcatenado">Número de adenda concatenado</param>
/// <returns>Registro de adenda en tabla temporal</returns>
int RegistraAdendaContratoVencido(Guid unidadOperativa, string numeroContrato, string descripcion, int numeroAdenda, string numeroAdendaConcatenado);
/// <summary>
/// Método para listar los contrato por usuario.
/// </summary>
/// <param name="CodigoResponsable">Codigo de trabajador que consulta</param>
/// <param name="UnidadOperativa">Código de Unidad Operativa</param>
/// <param name="NombreProveedor">Nombre del proveedor</param>
/// <param name="NumdocPrv">Número de documento del proveedor</param>
/// <param name="TipoServicio">Tipo de Servicio</param>
/// <param name="TipoReq">Tipo de Requerimiento</param>
/// <param name="nombreEstadio">Nombre de estadio</param>
/// <param name="indicadorFinalizarAprobacion">Indicador de finalizar aprobación</param>
/// <param name="columnaOrden">Columna para ordenar</param>
/// <param name="tipoOrden">Tipo de ordenamiento</param>
/// <param name="numeroPagina">Número de página</param>
/// <param name="registroPagina">Número de registros por página</param>
/// <returns>Lista de bandeja de contratos</returns>
List<ContratoLogic> ListaBandejaContratosOrdenado(
Guid CodigoResponsable,
Guid? UnidadOperativa,
string NombreProveedor,
string NumdocPrv,
string TipoServicio,
string TipoReq,
string nombreEstadio,
string indicadorFinalizarAprobacion,
string columnaOrden,
string tipoOrden,
int numeroPagina,
int registroPagina);
/// <summary>
/// Metodo para obtener el estadio de edición de un flujo de aprobación de un contrato
/// </summary>
/// <param name="codigoContrato">Código contrato</param>
/// <param name="codigoFlujoAprobacion">Código flujo de aprobación</param>
/// <returns>Código de contrato estadio de edición</returns>
Guid ObtenerContratoEstadioEdicion(Guid codigoContrato, Guid? codigoFlujoAprobacion);
/// <summary>
/// Metodo para obtener el responsable de edición de un estadio
/// </summary>
/// <param name="codigoContratoEstadio">Código contrato estadio</param>
/// <param name="codigoEstadioRetorno">Código estadio retorno</param>
/// <param name="codigoResposable">Código responsale</param>
/// <returns>Código responsable de estadio de edición</returns>
Guid ObtenerResponsableContratoEstadioEdicion(Guid codigoContratoEstadio, Guid codigoEstadioRetorno, Guid codigoResposable);
/// <summary>
/// Método para obtener la empresa vinculada por proveedor
/// </summary>
/// <param name="codigoProveedor">Código de proveedor</param>
/// <returns>Datos de empresa vinculada</returns>
EmpresaVinculadaLogic ObtenerEmpresaVinculadaPorProveedor(Guid? codigoProveedor);
/// <summary>
/// Método para listar los contratos aprobados en la solicitud de modificación.
/// </summary>
/// <param name="NumeroContrato">número del contrato</param>
/// <param name="UnidadOperativa">unidad operativa</param>
/// <param name="NombreProveedor">nombre del proveedor</param>
/// <param name="NumdocPrv">numero documento del proveedor</param>
/// <returns>Listado de contratos para revisión</returns>
List<ContratoLogic> ListaBandejaRevisionContratos(string NumeroContrato, Guid? UnidadOperativa, string NombreProveedor, string NumdocPrv);
/// <summary>
/// AutoComplete Numero Contrato
/// </summary>
/// <param name="codigoUnidadOperativa"></param>
/// <param name="numeroContrato"></param>
/// <param name="numeroPagina"></param>
/// <param name="registroPagina"></param>
/// <returns></returns>
List<ContratoLogic> BuscarNumeroContrato(Guid? codigoUnidadOperativa, string numeroContrato, int numeroPagina, int registroPagina);
/// <summary>
/// Reporte Contrato Observado Aprobado
/// </summary>
/// <param name="codigoUnidadOperativa"></param>
/// <param name="codigoContrato"></param>
/// <param name="tipoAccion"></param>
/// <param name="fechaInicio"></param>
/// <param name="fechaFin"></param>
/// <param name="nombreBaseDatoPolitica"></param>
/// <param name="numeroPagina"></param>
/// <param name="registroPagina"></param>
/// <returns></returns>
List<ContratoObservadoAprobadoLogic> BuscarContratoObservadoAprobado(Guid? codigoUnidadOperativa,
Guid? codigoContrato,
string tipoAccion,
DateTime? fechaInicio,
DateTime? fechaFin,
string nombreBaseDatoPolitica,
int numeroPagina,
int registroPagina);
}
}
|
using Welic.Dominio.Utilitarios.Entidades;
namespace Welic.Dominio.TiposDados
{
public class Descricao
{
private string _valor;
public string Valor
{
get => _valor;
private set => _valor = FormatacaoString.Padronizar(value);
}
public string ValorResumido => ObterValorResumido(_valor);
public string ObterValorResumido(string valor)
{
if (!string.IsNullOrEmpty(valor))
{
return valor.Length > 20 ? valor.Substring(0, 20) : valor;
}
return string.Empty;
}
protected Descricao()
{
}
public Descricao(string valor)
{
Valor = valor;
}
public void LimparDescricao()
{
Valor = "";
}
public static implicit operator string(Descricao descricao)
{
return descricao.Valor;
}
public static implicit operator Descricao(string descricao)
{
return new Descricao(descricao);
}
}
} |
using System.Collections.Generic;
namespace Mathematics
{
public class Calculator
{
const float PI = 3.1415926f;
public static int Factorial(int num)
{
if (num == 0) return 1;
return num * Factorial(num - 1);
}
public static float RoundDecimal(float num, int numOfDecimalPlaces)
{
string numStr = num.ToString();
string[] subs = numStr.Split('.');
try { return float.Parse(numStr.Remove(subs[0].Length + 1 + numOfDecimalPlaces)); }
catch { return -1f; }
}
public static int Power(int bas, int exp)
{
int result = bas;
if (exp == 0) return 1;
for (byte i = 0; i < exp - 1; i++)
{
result = result * bas;
}
return result;
}
public static float Power(float bas, int exp)
{
float result = bas;
if (exp == 0) return 1;
for (byte i = 0; i < exp - 1; i++)
{
result = result * bas;
}
return result;
}
public static int Root(int num, int root)
{
int hi = num;
int lo = 1;
int result = 1;
for (byte i = 0; i < num / 4; i++)
{
result = (hi + lo) / 2;
if (Power(result, root) == num) return result;
else if (Power(result, root) > num) hi = result;
else lo = result;
}
return result;
}
public static int[] Factor(int num)
{
List<int> output = new List<int>();
int result = num;
for (int i = 0; i < num; i++)
{
if (result % 5 == 0) { result /= 5; output.Add(5); }
else if (result % 3 == 0) { result /= 3; output.Add(3); }
else if (result % 2 == 0) { result /= 2; output.Add(2); }
else { output.Add(num); output.Add(1); break; }
}
return output.ToArray();
}
public static float RectArea(float length, float width)
{
return length * width;
}
public static float CirArea(float radius)
{
return PI * Power(radius, 2);
}
public static float Circumference(float radius)
{
return PI * 2 * radius;
}
public static float TriArea(float bas, float height)
{
return (bas / 2) * height;
}
public static float PercentOf(float percent, float of) //ex. 20% of 40 is what?
{
return (percent * of) / 100;
}
public static int AsPercent(int x, int of) //ex. 20 is what percent of 40?
{
return (x * 100) / of;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SPZ_Lab1
{
//перечисление тарифов
public enum Tariff
{
VFSuperNetUnlim,
VFSuperNetPro,
VF_RED_EXTRA_L,
VF_RED_EXTRA_S
}
//перечисление услуг
public enum Service
{
VFMusic,
OnlinePASS,
VideoPASS,
InstaPASS,
YearWithoutPayment,
}
//класс "мобильного баланса"
class MobileBalance
{
//структура для хранения информации о звонке
struct Call
{
//поля для хранения данных о номере и длительности звонка
private readonly string _number;
private readonly int _callDuration;
//инициализирующий конструктор
public Call(string number, int duration)
{
_number = number;
_callDuration = duration;
}
public override string ToString()
{
return string.Format("Номер: {0}, продолжительность звонка: {1} минут(-ы).\n", _number, _callDuration);
}
}
private Tariff _tarifName; //название текущего тарифа
private float _minutePrice; //стоимость разговора в минуту с учетом тарифа
private float _currentBalance; //сумма на счету
private string _phoneNumber; //номер телефона
private List<Service> _services = new List<Service>(); //контейнер для хранения подключенных услуг
private List<Call> _callHistory = new List<Call>(); //контейнер для хранения истории вызовов
private static readonly float[] _tariffPrices = {0.1f, 0.2f, 0.5f, 2f}; //стоимость разговора на разных тарифам
private static readonly float[] _servicePrices = { 15f, 20f, 30f, 50f, 300f }; //стоимость подключения услуг
//реализация свойств из интерфейса
public Tariff TariffName
{
get
{
return _tarifName;
}
set
{
Array values = Enum.GetValues(typeof(Tariff));
if (((int[])values).Contains((int)value)) {
_tarifName = value;
}
else
{
_tarifName = Tariff.VF_RED_EXTRA_L;
}
}
}
public float MinutePrice
{
get
{
return _minutePrice;
}
private set
{
_minutePrice = value;
}
}
public float CurrentBalance
{
get
{
return _currentBalance;
}
set
{
if (value >= 0f && value <= 1000f)
{
_currentBalance = value;
}
else if (value > 1000f)
{
Console.WriteLine("\nСостояние счета не может превышать максимально допустимое значение (1000). На баланс была переведена недостающая до максимума сумма");
_currentBalance = 1000f;
}
else
{
Console.WriteLine("\nНа счету недостаточно средств!");
}
}
}
public string PhoneNumber
{
get
{
return _phoneNumber;
}
private set
{
if (isNumberCorrect(value))
{
_phoneNumber = value;
} else {
_phoneNumber = "+380-99-9999999";
}
}
}
//инициализирующий конструктор
public MobileBalance(
Tariff tarifName,
float currentBalance,
string phoneNumber,
params Service[] services
)
{
TariffName = tarifName;
MinutePrice = _tariffPrices[(int)TariffName];
CurrentBalance = currentBalance;
PhoneNumber = phoneNumber;
foreach(Service a in services)
{
_services.Add(a);
}
}
//конструктор по умолчанию
public MobileBalance() : this(Tariff.VF_RED_EXTRA_L,
0f,
"+380-99-999-9999"
) {}
//вспомогательная функция проверки корректности формата номера телефона
public static bool isNumberCorrect(string number)
{
int temp;
string[] numberParts = number.Split('-');
if (number.Length == 15 && numberParts.Length == 3 && numberParts[0] == "+380" && "66-50-99-95".Contains(numberParts[1]) && int.TryParse(numberParts[2], out temp) /*&& int.TryParse(numberParts[3], out temp)*/)
{
return true;
}
return false;
}
//вспомогательный метод выбора услуги по названию через консоль
public static Service ChooseService()
{
Service service;
Console.WriteLine("\nВведите название услуги \n(VFMusic / OnlinePASS / VideoPASS / InstaPASS / YearWithoutPayment):");
string str = Console.ReadLine();
if (!Enum.TryParse(str, out service))
{
Console.WriteLine("\nОшибка: Введено неверное название услуги.");
return (Service)(-1);
}
return service;
}
//вспомогательный метод выбора тарифа по названию через консоль
public static Tariff ChooseTariff()
{
Tariff tariff;
Console.WriteLine("\nВведите название тарифа \n(VFSuperNetUnlim / VFSuperNetPro / VF_RED_EXTRA_L / VF_RED_EXTRA_S):");
string str = Console.ReadLine();
if (!Enum.TryParse(str, out tariff))
{
Console.WriteLine("\nОшибка: Введено неверное название тарифа. Установлен тариф по умолчанию.");
return Tariff.VF_RED_EXTRA_L;
}
return tariff;
}
//изменение текущего тарифа
public void ChangeTariff(Tariff t)
{
TariffName = t;
MinutePrice = _tariffPrices[(int)t];
}
//звонок с указанием номера и длительности разговора
public float CallPhone(string phone, int minutes)
{
if (!isNumberCorrect(phone))
{
Console.WriteLine("\nНеверно набранный номер!");
return 0f;
}
if (minutes < 0)
{
Console.WriteLine("\nНекорректное значение длительности разговора!");
return 0f;
}
float CurrentSum = minutes * MinutePrice;
//если на указанну длительность разговора не хватает средств,
//совершить звонок на всю имеющуюся на счету сумму, рассчитать на сколько минут хватило этой суммы
if (CurrentSum > CurrentBalance)
{
minutes = (int)(CurrentBalance / MinutePrice);
CurrentSum = CurrentBalance;
}
CurrentBalance -= CurrentSum;
_callHistory.Add(new Call(phone, minutes));
Console.WriteLine("\nСовершен звонок на номер {0} длительностью {1} минут(-ы)\nСо счета списано {2} грн.", phone, minutes, CurrentSum);
return CurrentSum;
}
//звонок с указанием номера и случайной длительностью (1 - 180 минут)
public float CallPhone(string phone)
{
Random rand = new Random();
return CallPhone(phone, rand.Next(1, 180));
}
//пополнение счета на указанную сумму
public void RefillBalance(float sum)
{
if (sum > 0)
{
CurrentBalance += sum;
Console.WriteLine("\nБаланс успешно пополнен!");
} else
{
Console.WriteLine("\nУказана некорректная сумма!");
}
}
//подключить услугу
public void AddService(Service serviceName)
{
if (_services.Contains(serviceName))
{
Console.WriteLine("\nУслуга {0} уже подключена для данного номера ({1})", serviceName.ToString(), PhoneNumber);
}
else if ((int)serviceName == -1)
{
return;
}
else if (((int)serviceName) > _servicePrices.Length - 1 || ((int)serviceName) < 0)
{
Console.WriteLine("Имя услуги указано неверно!");
}
else if (CurrentBalance < _servicePrices[(int)serviceName])
{
Console.WriteLine("недостаточно средств для подключения услуги!");
}
else
{
_services.Add(serviceName);
CurrentBalance -= _servicePrices[(int)serviceName];
Console.WriteLine("\nПо номеру {0} была успешно подключена услуга {1}.\nСо счета была списана плата за данную услугу за месяц использования ({2} грн)", PhoneNumber, serviceName.ToString(), _servicePrices[(int)serviceName]);
}
}
//отключить услугу
public void RemoveService(Service serviceName)
{
if (_services.Contains(serviceName))
{
_services.Remove(serviceName);
Console.WriteLine("\nУслуга {0} была успешно отключена", serviceName.ToString());
}
else if ((int)serviceName == -1)
{
return;
}
else
{
Console.WriteLine("\nУслуга {0} не подключена!", serviceName.ToString());
}
}
//вывод состояния баланса на консоль
public void PrintState()
{
Service[] arr = _services.ToArray();
//int a = arr.Length;
StringBuilder serviceNames = new StringBuilder("");
if (arr.Length > 0)
{
serviceNames.Append(arr[0]);
for (int i = 1; i < arr.Length; i++)
{
serviceNames.Append(", " + arr[i]);
}
}
Console.WriteLine("\n*******************************************************************************\n" +
"Номер телефона: {0}\n" +
"Текущий баланс: {1} грн\n" +
"Текущий тариф: {2} (Стоимость разговора в минуту - {3} грн)\n" +
"Подключенные услуги: {4}\n" +
"*******************************************************************************",
PhoneNumber, CurrentBalance, TariffName, MinutePrice, serviceNames.ToString());
}
//вывод истории звонков на консоль
public void PrintCallHistory()
{
if (_callHistory.Count == 0)
{
Console.WriteLine("\nИстория вызовов пуста!");
return;
}
StringBuilder callNames = new StringBuilder("");
for (int i = 0; i < _callHistory.Count; i++)
{
callNames.Append(_callHistory[i].ToString());
}
Console.WriteLine("\nИстория звонков:\n{0}", callNames);
}
}
}
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
using IRAP.Global;
using IRAP.Client.User;
using IRAP.Client.SubSystem;
using IRAP.Entity.Kanban;
using IRAP.Entity.MES;
using IRAP.Entity.SSO;
using IRAP.Entities.MDM;
using IRAP.WCF.Client.Method;
namespace IRAP.Client.GUI.MESPDC
{
public partial class frmManufactureRecord : IRAP.Client.Global.GUI.frmCustomFuncBase
{
private static string className = MethodBase.GetCurrentMethod().DeclaringType.FullName;
private List<StationPortInfo> ports = new List<StationPortInfo>();
private List<ScannerForSerialPort> scanners = new List<ScannerForSerialPort>();
private List<ManufactureRecordLog> logs = new List<ManufactureRecordLog>();
private List<ScannerView> scannerViews = new List<ScannerView>();
public frmManufactureRecord()
{
InitializeComponent();
string strProcedureName =
string.Format(
"{0}.{1}",
className,
MethodBase.GetCurrentMethod().Name);
#region 从数据库中获取当前站点配置的串口扫描枪的信息列表
{
int errCode = 0;
string errText = "";
WriteLog.Instance.WriteBeginSplitter(strProcedureName);
try
{
IRAPKBClient.Instance.ufn_GetKanban_Station_Ports(
IRAPUser.Instance.CommunityID,
IRAPUser.Instance.SysLogID,
0,
ref ports,
out errCode,
out errText);
WriteLog.Instance.Write(
string.Format("({0}){1}", errCode, errText),
strProcedureName);
}
finally
{
WriteLog.Instance.WriteEndSplitter(strProcedureName);
}
}
#endregion
#region 根据上面获取到的串口扫描枪信息列表，创建串口扫描枪读取对象列表，并开始侦听
{
try
{
foreach (StationPortInfo port in ports)
{
if (port.IsComm)
{
ScannerForSerialPort scanner = new ScannerForSerialPort(lstBarCodes, port);
scanners.Add(scanner);
scannerViews.Add(
new ScannerView()
{
PortName = port.CommPort,
WorkUnitCode = port.WorkUnitCode,
WorkUnitName = port.WorkUnitName,
});
}
}
}
catch (Exception error)
{
WriteLog.Instance.Write(error.Message, strProcedureName);
WriteLog.Instance.Write(error.StackTrace, strProcedureName);
}
}
#endregion
grdSerialPortScanners.DataSource = scannerViews;
grdBarCodeLogs.DataSource = logs;
grdvSerialPortScanners.BestFitColumns();
grdvBarCodeLogs.BestFitColumns();
timer.Enabled = true;
}
private void frmManufactureRecord_Activated(object sender, EventArgs e)
{
Options.Visible = true;
if (Options.SelectStation != null)
{
edtContainerNo1.Text = Options.SelectStation.T107G02;
edtContainerNo2.Text = Options.SelectStation.T107G03;
}
}
private void frmManufactureRecord_FormClosed(object sender, FormClosedEventArgs e)
{
for (int i = scanners.Count - 1; i >= 0; i--)
{
scanners[i].Close();
}
}
private void timer_Tick(object sender, EventArgs e)
{
string strProcedureName =
string.Format(
"{0}.{1}",
className,
MethodBase.GetCurrentMethod().Name);
timer.Enabled = false;
try
{
string barCode = "";
// 从条码池中获取一条待处理的在产品条码
lstBarCodes.Invoke(
new EventHandler(
delegate
{
if (lstBarCodes.Items.Count > 0)
{
object item = lstBarCodes.Items[0];
barCode = lstBarCodes.Items[0].ToString();
lstBarCodes.Items.Remove(item);
}
}));
string[] splitString = barCode.Split('|');
if (splitString.Length <= 1)
{
return;
}
foreach (ScannerView view in scannerViews)
{
if (view.PortName == splitString[0])
{
view.BarCode = splitString[1];
grdvSerialPortScanners.BestFitColumns();
if (Options.SelectStation == null ||
Options.SelectProduct == null)
{
WriteToScreenLog(
view.BarCode,
"",
"",
-1,
"当前站点没有配置产品流程和或工位");
return;
}
WriteLog.Instance.WriteBeginSplitter(strProcedureName);
try
{
int errCode = 0;
string errText = "";
WIPBarCodeInfo barcodeInfo = new WIPBarCodeInfo();
#region 获取条码信息
IRAPMESClient.Instance.ufn_GetInfo_WIPBarcode(
IRAPUser.Instance.CommunityID,
view.BarCode,
Options.SelectProduct.T120LeafID,
Options.SelectStation.T107LeafID,
ref barcodeInfo,
out errCode,
out errText);
WriteLog.Instance.Write(
string.Format("({0}){1}", errCode, errText),
strProcedureName);
if (errCode != 0)
{
WriteToScreenLog(
view.BarCode,
"",
"",
errCode,
errText);
return;
}
#endregion
#region 根据条码信息中的条码状态和路由状态，进行生产记载
switch (barcodeInfo.BarcodeStatus)
{
case 0:
switch (barcodeInfo.RoutingStatus)
{
case 1:
break;
default:
WriteToScreenLog(
view.BarCode,
"",
"",
barcodeInfo.RoutingStatus,
barcodeInfo.RoutingStatusStr);
return;
}
break;
case 1:
switch (barcodeInfo.RoutingStatus)
{
case 1:
// 自动切换工艺流程
ProductViaStation product =
AvailableProducts.Instance.GetProductWithLeafID(barcodeInfo.ProcessLeaf);
if (product == null)
{
WriteToScreenLog(
view.BarCode,
"",
barcodeInfo.SerialNumber,
-1,
"该条码的在产品生产流程不在当前工位上");
return;
}
else
{
CurrentOptions.Instance.OptionTwo = product;
Options.RefreshOptionTwo(product.T102LeafID);
}
break;
default:
WriteToScreenLog(
view.BarCode,
"",
"",
barcodeInfo.BarcodeStatus,
barcodeInfo.BarcodeStatusStr);
return;
}
break;
case 7:
return;
default:
WriteToScreenLog(
view.BarCode,
"",
"",
barcodeInfo.BarcodeStatus,
barcodeInfo.BarcodeStatusStr);
return;
}
long transactNo = 0;
long factID = 0;
// 申请交易号
transactNo =
IRAPUTSClient.Instance.mfn_GetTransactNo(
IRAPUser.Instance.CommunityID,
1,
IRAPUser.Instance.SysLogID,
"14");
// 申请事实编号
factID =
IRAPUTSClient.Instance.mfn_GetFactID(
IRAPUser.Instance.CommunityID,
barcodeInfo.NumOfSubPCBs,
IRAPUser.Instance.SysLogID,
"0");
IRAPMESClient.Instance.usp_ManufactureRecord(
IRAPUser.Instance.CommunityID,
transactNo,
factID,
Options.SelectProduct.T120LeafID,
Options.SelectStation.T107LeafID,
view.BarCode,
barcodeInfo.SerialNumber,
IRAPUser.Instance.SysLogID,
out errCode,
out errText);
WriteToScreenLog(
view.BarCode,
"",
barcodeInfo.SerialNumber,
errCode,
errText);
#endregion
}
catch (Exception error)
{
WriteLog.Instance.Write(error.Message, strProcedureName);
WriteToScreenLog(
view.BarCode,
"",
"",
-1,
error.Message);
}
finally
{
WriteLog.Instance.WriteEndSplitter(strProcedureName);
}
}
}
}
finally
{
timer.Enabled = true;
}
}
private void WriteToScreenLog(
string mainBarCode,
string subBarCode,
string serialNumber,
int errCode,
string errText)
{
if (logs.Count >= 100)
{
logs.RemoveRange(99, logs.Count - 99);
}
logs.Insert(
0,
new ManufactureRecordLog()
{
ProcessTime = DateTime.Now.ToString(),
MainBarCode = mainBarCode,
SubBarCode = subBarCode,
SerialNumber = serialNumber,
ResultCode = errCode,
ResultMessage = errText,
});
grdvBarCodeLogs.BestFitColumns();
}
}
internal class ManufactureRecordLog
{
public string ProcessTime { get; set; }
public string MainBarCode { get; set; }
public string SubBarCode { get; set; }
public string SerialNumber { get; set; }
public int ResultCode { get; set; }
public string ResultMessage { get; set; }
}
internal class ScannerView
{
public string PortName { get; set; }
public string WorkUnitCode { get; set; }
public string WorkUnitName { get; set; }
public int WorkUnitLeafID { get; set; }
public string BarCode { get; set; }
}
}
|
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using TcpServerLibrary;
namespace ServerLibrary
{
public class AsyncTcpServer : AbstractServer
{
public delegate void TransmissionDataDelegate(NetworkStream stream);
public AsyncTcpServer(IPAddress IP, int port) : base(IP, port)
{
}
protected override void AcceptClient()
{
while (true)
{
tcpClient = TcpListener.AcceptTcpClient();
networkStream = tcpClient.GetStream();
TransmissionDataDelegate transmissionDelegate = new TransmissionDataDelegate(BeginDataTransmission);
transmissionDelegate.BeginInvoke(networkStream, TransmissionCallback, tcpClient);
Console.WriteLine("Client connected");
}
}
private void TransmissionCallback(IAsyncResult ar)
{
tcpClient.Close();
}
public override void Start()
{
StartListening();
AcceptClient();
}
protected override void BeginDataTransmission(NetworkStream stream)
{
TcpMenu menu = new TcpMenu();
while (true)
{
while (menu.LoginMenu(stream))
{
menu.ShowMenu(stream);
}
}
}
}
}
|
using System;
namespace Week12ICE1
{
class MainClass
{
public static void Main(string[] args)
{
while (true)
{
Console.Clear();
Fare fare = new Fare();
const int maxHours = 8;
Console.WriteLine("Please enter rental time in hours.");
double hoursRented = double.Parse(Console.ReadLine());
Console.WriteLine("Do you have a parking pass? Y or N?");
string yN = Console.ReadLine();
while (hoursRented <= maxHours && hoursRented > 0)
{
// declares a current time
DateTime time = DateTime.Now;
// calculates the customer fare based on parking pass
double customerFare;
if (yN == "Y"){
customerFare = fare.CalculateFareY(hoursRented);
}
else{
customerFare = fare.CalculateFareN(hoursRented);
}
// prints customer parking pass statement
Console.WriteLine(fare.PassCustomer(yN));
// get time when rental is oevr
DateTime expiredTime = time.AddHours(hoursRented);
Console.WriteLine("Your total is {0:C}. Your time expires at {1}.", customerFare, expiredTime);
// clears console for next user and breaks out of loop
Console.ReadLine();
break;
}
}
}
public class Fare : ParkingPass
{
protected const double hourlyRate = 2.5;
public double CalculateFareN(double hoursRented){
double fare = hourlyRate * hoursRented;
return fare;
}
public double CalculateFareY(double hoursRented){
return 0;
}
}
public class ParkingPass
{
public string PassCustomer(string yN){
if (yN == "Y")
{
return "You don't need to pay.";
}
else
{
return "You need to pay.";
}
}
}
}
} |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Painter : MonoBehaviour
{
public GameObject flare;
public Camera mainCam, canvasCam;
public RenderTexture painterTexture;
public Material baseMaterial; // material to paint;
private Texture baseMaterialTexture;
RaycastHit hit;
Ray ray;
//Vector3 first;
//Vector3 second;
//Vector3 size;
public GameObject Brush;
public GameObject BrushContainer;
public Color BrushColor;
public float BrushSize;
private int brushCount = 0;
private readonly int maxBrushCount = 300;
bool saving = false;
void Start()
{
baseMaterialTexture = baseMaterial.mainTexture; // saving base texture before painting
//size = Brush.GetComponent<SpriteRenderer>().bounds.size;
}
void Update()
{
if (!saving)
{
//Raycasting---------------------------------------------------------------------------------------------------------------- -
if (Application.platform == RuntimePlatform.WebGLPlayer || Application.platform == RuntimePlatform.WindowsEditor)
{
if (Input.GetMouseButton(0))
{
ray = mainCam.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit))
{
if (hit.collider.gameObject.CompareTag("PaintObject"))
{
//Instantiate(flare, hit.point, Quaternion.identity);
Paint(hit.point);
//first = hit.point;
}
}
}
}
if (Application.platform == RuntimePlatform.Android)
{
if (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Began)
{
for (var i = 0; i < Input.touchCount; i++)
{
ray = mainCam.ScreenPointToRay(Input.GetTouch(0).position);
if (Physics.Raycast(ray, out hit))
{
if (hit.collider.gameObject.CompareTag("PaintObject"))
{
//Instantiate(flare, hit.point, Quaternion.identity);
Paint(hit.point);
}
}
}
}
//if(Input.touchCount>0 && Input.GetTouch(0).phase == TouchPhase.Moved)
//{
// ray = mainCam.ScreenPointToRay(Input.GetTouch(0).position);
// if (Physics.Raycast(ray, out hit))
// {
// if (hit.collider.gameObject.CompareTag("PaintObject"))
// {
// //Instantiate(flare, hit.point, Quaternion.identity);
// secondFrame = hit.point;
// PaintBetweenFrames();
// }
// }
//}
}
}
//-------------------------end of Raycasting ---------------------------------------------------------
}
//private void LateUpdate()
//{
// if (Input.GetMouseButton(0))
// {
// ray = mainCam.ScreenPointToRay(Input.mousePosition);
// if (Physics.Raycast(ray, out hit))
// {
// if (hit.collider.gameObject.CompareTag("PaintObject"))
// {
// second = hit.point;
// ColourBetween(first, second);
// }
// }
// print("late"+first+" "+second);
// }
//}
private void OnApplicationQuit()
{
baseMaterial.mainTexture = baseMaterialTexture; // reversing all changes to texture;
}
private void Paint(Vector3 rhit)
{
GameObject brushObject = Instantiate(Brush);
BrushColor.a = 1;
brushObject.GetComponent<SpriteRenderer>().color = BrushColor;
brushObject.transform.parent = BrushContainer.transform;
brushObject.transform.position = rhit;
brushObject.transform.localScale = Vector3.one * BrushSize;
brushObject.layer = 8;
brushCount++;
if(brushCount>=maxBrushCount)
{
brushCount = 0;
Brush.SetActive(false);
Save();
}
}
public void ColourBetween(Vector3 start_point, Vector3 end_point)
{
// Get the distance from start to finish
float distance = Vector3.Distance(start_point, end_point);
//Vector3 direction = (start_point - end_point).normalized;
Vector3 cur_position;// = start_point; // Calculate how many times we should interpolate between start_point and end_point based on the amount of time that has passed since the last update
float lerp_steps = 1 / distance;
print(distance);
for (float lerp = 0; lerp <= 1; lerp += lerp_steps)
{
cur_position = Vector3.Lerp(start_point, end_point, lerp);
Paint(cur_position);
}
}
private void Save()
{
saving = true;
RenderTexture.active = painterTexture;
Texture2D tex = new Texture2D(painterTexture.width, painterTexture.height, TextureFormat.RGB24, false);
tex.ReadPixels(new Rect(0, 0, painterTexture.width, painterTexture.height), 0, 0);
tex.Apply();
RenderTexture.active = null;
baseMaterial.mainTexture = tex;
foreach (Transform child in BrushContainer.transform)
{
Destroy(child.gameObject);
}
Brush.SetActive(true);
saving = false;
}
}
|
using System.Collections.Generic;
using System.Linq;
using DataAccess.Model;
using KioskClient.ViewModel;
using NUnit.Framework;
using Tests.Stubs;
namespace Tests
{
[TestFixture]
public class WhenFilteringMovies
{
[SetUp]
public void SetUp()
{
movieRepository = new MovieRepositoryStub();
var genre1 = new Genre {Name = "action"};
var genre2 = new Genre {Name = "comedy" };
var genre3 = new Genre {Name = "adventure" };
var movie1 = new Movie {Title = "Action Movie", Genres = new List<Genre> {genre1}};
var movie2 = new Movie {Title = "Comedy Movie", Genres = new List<Genre> {genre2}};
var movie3 = new Movie {Title = "Adventure Movie", Genres = new List<Genre> {genre3}};
movieRepository.GenresStorage = new List<Genre> {genre1, genre2, genre3};
movieRepository.MoviesStorage = new List<Movie> {movie1, movie2, movie3};
}
private MovieRepositoryStub movieRepository;
[Test]
public void AllMoviesShownIfNoGenreSelected()
{
var viewModel = new CatalogPageViewModel(null, movieRepository);
viewModel.Genres[0].IsSelected = false;
viewModel.Genres[1].IsSelected = false;
viewModel.Genres[2].IsSelected = false;
Assert.AreEqual(viewModel.Movies.Count, 3);
}
[Test]
public void FilterIsReset()
{
var viewModel = new CatalogPageViewModel(null, movieRepository);
viewModel.Genres[0].IsSelected = true;
viewModel.Genres[1].IsSelected = true;
viewModel.ResetGenresFilter();
Assert.AreEqual(viewModel.Movies.Count, 3);
}
[Test]
public void OneMovieIsFiltered()
{
var viewModel = new CatalogPageViewModel(null, movieRepository);
viewModel.Genres[0].IsSelected = true;
Assert.AreEqual(viewModel.Movies.Count, 1);
Assert.AreEqual(viewModel.Movies[0].Title, "Action Movie");
}
[Test]
public void TwoMoviesAreFiltered()
{
var viewModel = new CatalogPageViewModel(null, movieRepository);
viewModel.Genres[0].IsSelected = true;
viewModel.Genres[1].IsSelected = true;
Assert.AreEqual(viewModel.Movies.Count, 2);
Assert.AreEqual(viewModel.Movies[0].Title, "Action Movie");
Assert.AreEqual(viewModel.Movies[1].Title, "Comedy Movie");
}
}
} |
using System;
namespace DXF.Objetos
{
/// <summary>
/// Clase de base de todos los objetos dxf
/// </summary>
public class DxfObjeto
{
#region propiedades privadas
private readonly string codNombre;
private string handle;
#endregion
#region constructores
/// <summary>
/// Inicializa una nueva instancia de la clase <c>DxfObjeto</c>
/// </summary>
public DxfObjeto(string codNombre)
{
this.codNombre = codNombre;
}
#endregion
#region propiedades publicas
/// <summary>
/// Obtiene el tipo string de la entidad dxf
/// </summary>
public string CodNombre
{
get { return this.codNombre; }
}
/// <summary>
/// Obtiene o establece el handle del objeto dxf
/// </summary>
public string Handle
{
get { return this.handle; }
internal set { this.handle = value; }
}
#endregion
#region metodos publicos
/// <summary>
/// Asigna un handle al objeto basado en un contador int
/// </summary>
/// <param name="entidadNro">Numero a asignar</param>
/// <returns>Proximo numero de entidad disponible</returns>
/// <remarks>
/// Algunos objetos pueden consumir mas de uno, x ej, el caso de las multipleslineas que asignan
/// un handle a sus vertices.
/// </remarks>
internal virtual int AsignarHandle(int entidadNro)
{
this.handle = Convert.ToString(entidadNro, 16);
return entidadNro + 1;
}
#endregion
}
}
|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Castle.Services.Transaction;
using com.Sconit.Entity;
using com.Sconit.Entity.ACC;
using com.Sconit.Entity.Exception;
using com.Sconit.Entity.INV;
using com.Sconit.Entity.MD;
using com.Sconit.Entity.ORD;
using com.Sconit.Entity.VIEW;
using System.IO;
using NHibernate.Type;
using NHibernate;
using NPOI.HSSF.UserModel;
using NPOI.SS.UserModel;
using com.Sconit.Utility;
using com.Sconit.Entity.CUST;
using com.Sconit.Entity.SYS;
using com.Sconit.Entity.INP;
namespace com.Sconit.Service.Impl
{
[Transactional]
public class MiscOrderMgrImpl : BaseMgr, IMiscOrderMgr
{
#region 变量
public IGenericMgr genericMgr { get; set; }
public INumberControlMgr numberControlMgr { get; set; }
public ISystemMgr systemMgr { get; set; }
public IHuMgr huMgr { get; set; }
public ILocationDetailMgr locationDetailMgr { get; set; }
public IItemMgr itemMgr { get; set; }
#endregion
private static string selectInspectResult = @"select r from InspectResult r where r.InspectNo = ? and r.RejectHandleResult=?
and r.IsHandle=? and r.JudgeQty > r.HandleQty";
private static string selectRejectDetail = @"select r from RejectDetail as r where r.RejectNo=? and r.HandleQty > r.HandledQty
and exists (select 1 from RejectMaster as m where r.RejectNo = m.RejectNo and m.HandleResult =? )";
[Transaction(TransactionMode.Requires)]
public void CreateMiscOrder(MiscOrderMaster miscOrderMaster)
{
miscOrderMaster.MiscOrderNo = this.numberControlMgr.GetMiscOrderNo(miscOrderMaster);
if (string.IsNullOrWhiteSpace(miscOrderMaster.DeliverRegion))
{
//非跨工厂移库时，会从Region字段找到对应的Plant填到该字段上面
miscOrderMaster.DeliverRegion = this.genericMgr.FindById<Region>(miscOrderMaster.Region).Plant;
}
this.genericMgr.Create(miscOrderMaster);
if (miscOrderMaster.MiscOrderDetails != null && miscOrderMaster.MiscOrderDetails.Count > 0)
{
BatchUpdateMiscOrderDetails(miscOrderMaster, miscOrderMaster.MiscOrderDetails, null, null);
}
}
[Transaction(TransactionMode.Requires)]
public void QuickCreateMiscOrder(MiscOrderMaster miscOrderMaster, DateTime effectiveDate)
{
miscOrderMaster.MiscOrderNo = this.numberControlMgr.GetMiscOrderNo(miscOrderMaster);
this.genericMgr.Create(miscOrderMaster);
#region 更新引用的明细状态
if (miscOrderMaster.ReferenceDocumentsType > 0)
{
if (miscOrderMaster.QualityType != CodeMaster.QualityType.Reject)
{
throw new BusinessException("不合格品报废请选择质量类型为不合格");
}
if (miscOrderMaster.MoveType != "201")
{
throw new BusinessException("不合格品报废的移动类型应该为201");
}
List<string> huList = new List<string>();
if (miscOrderMaster.ReferenceDocumentsType == (int)CodeMaster.DocumentsType.INS)
{
var inspectResultList = genericMgr.FindAll<InspectResult>(selectInspectResult,
new object[] { miscOrderMaster.ReferenceNo, com.Sconit.CodeMaster.HandleResult.Scrap, false });
foreach (var inspectResult in inspectResultList)
{
inspectResult.HandleQty = inspectResult.JudgeQty;
inspectResult.IsHandle = true;
genericMgr.Update(inspectResult);
}
huList = inspectResultList.Select(p => p.HuId).Distinct().ToList();
}
else if (miscOrderMaster.ReferenceDocumentsType == (int)CodeMaster.DocumentsType.REJ)
{
var rejectDetailList = genericMgr.FindAll<RejectDetail>(selectRejectDetail,
new object[] { miscOrderMaster.ReferenceNo, com.Sconit.CodeMaster.HandleResult.Scrap });
foreach (var rejectDetail in rejectDetailList)
{
rejectDetail.HandledQty = rejectDetail.HandleQty;
genericMgr.Update(rejectDetail);
}
RejectMaster rejectMaster = genericMgr.FindById<RejectMaster>(miscOrderMaster.ReferenceNo);
rejectMaster.Status = CodeMaster.RejectStatus.Close;
genericMgr.Update(rejectMaster);
huList = rejectDetailList.Select(p => p.HuId).Distinct().ToList();
}
if (miscOrderMaster.IsScanHu)
{
miscOrderMaster.MiscOrderDetails = new List<MiscOrderDetail>();
this.BatchUpdateMiscOrderDetails(miscOrderMaster, huList, null);
}
}
#endregion
this.CreateMiscOrderDetail(miscOrderMaster.MiscOrderDetails, miscOrderMaster.MiscOrderNo);
this.CloseMiscOrder(miscOrderMaster, effectiveDate);
}
[Transaction(TransactionMode.Requires)]
public void UpdateMiscOrder(MiscOrderMaster miscOrderMaster)
{
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Create)
{
throw new BusinessException("计划外出入库单{0}的状态为{1}不能修改。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
this.genericMgr.Update(miscOrderMaster);
}
[Transaction(TransactionMode.Requires)]
public void BatchUpdateMiscLocationOrderDetails(string miscOrderNo,
IList<MiscOrderDetail> addMiscOrderDetailList, IList<MiscOrderDetail> updateMiscOrderDetailList, IList<MiscOrderLocationDetail> deleteMiscOrderLocationDetailList)
{
BatchUpdateMiscLocationOrderDetails(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo), addMiscOrderDetailList, updateMiscOrderDetailList, deleteMiscOrderLocationDetailList);
}
[Transaction(TransactionMode.Requires)]
public void BatchUpdateMiscLocationOrderDetails(MiscOrderMaster miscOrderMaster,
IList<MiscOrderDetail> addMiscOrderDetailList, IList<MiscOrderDetail> updateMiscOrderDetailList, IList<MiscOrderLocationDetail> deleteMiscOrderLocationDetailList)
{
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Create)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
throw new BusinessException("计划外出库单{0}的状态为{1}不能修改明细。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
else
{
throw new BusinessException("计划外入库单{0}的状态为{1}不能修改明细。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
}
#region 新增计划外出入库明细
if (addMiscOrderDetailList != null && addMiscOrderDetailList.Count > 0)
{
#region 获取最大订单明细序号
string hql = "select max(Sequence) as seq from MiscOrderDetail where MiscOrderNo = ?";
IList<object> maxSeqList = genericMgr.FindAll<object>(hql, miscOrderMaster.MiscOrderNo);
int maxSeq = maxSeqList[0] != null ? (int)(maxSeqList[0]) : 0;
#endregion
#region 数量处理
foreach (MiscOrderDetail miscOrderDetail in addMiscOrderDetailList)
{
//Item item = this.genericMgr.FindById<Item>(miscOrderDetail.Item);
miscOrderDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo;
miscOrderDetail.Sequence = ++maxSeq;
//miscOrderDetail.Item = miscOrderDetail.Item;
//miscOrderDetail.ItemDescription = item.Description;
//miscOrderDetail.ReferenceItemCode = item.ReferenceCode;
//miscOrderDetail.Uom = miscOrderDetail.Uom;
//miscOrderDetail.BaseUom = item.Uom;
//miscOrderDetail.UnitCount = miscOrderDetail.UnitCount;
if (miscOrderDetail.Uom != miscOrderDetail.BaseUom)
{
miscOrderDetail.UnitQty = this.itemMgr.ConvertItemUomQty(miscOrderDetail.Item, miscOrderDetail.BaseUom, 1, miscOrderDetail.Uom);
}
else
{
miscOrderDetail.UnitQty = 1;
}
//miscOrderDetail.ReserveNo = miscOrderDetail.ReserveNo;
//miscOrderDetail.ReserveLine = miscOrderDetail.ReserveLine;
//miscOrderDetail.Qty = miscOrderDetail.Qty;
this.genericMgr.Create(miscOrderDetail);
if (miscOrderMaster.MiscOrderDetails == null)
{
miscOrderMaster.MiscOrderDetails = new List<MiscOrderDetail>();
}
//miscOrderMaster.MiscOrderDetails.Add(miscOrderDetail);
}
#endregion
}
#endregion
#region 修改计划外出入库明细
if (updateMiscOrderDetailList != null && updateMiscOrderDetailList.Count > 0)
{
foreach (MiscOrderDetail miscOrderDetail in updateMiscOrderDetailList)
{
if (miscOrderDetail.Uom != miscOrderDetail.BaseUom)
{
miscOrderDetail.UnitQty = this.itemMgr.ConvertItemUomQty(miscOrderDetail.Item, miscOrderDetail.BaseUom, 1, miscOrderDetail.Uom);
}
else
{
miscOrderDetail.UnitQty = 1;
}
this.genericMgr.Update(miscOrderDetail);
}
}
#endregion
#region 删除计划外出入库明细
//删除OrderDet
IList<string> para = new List<string>();
para.Add(deleteMiscOrderLocationDetailList.FirstOrDefault().MiscOrderNo);
//para.Add(miscOrderLocationDetail.Item);
IList<MiscOrderLocationDetail> miscOrderLocationDetails = genericMgr.FindAll<MiscOrderLocationDetail>(@"
from MiscOrderLocationDetail as m where m.MiscOrderNo = ? ", para);
var deleteItemCount = from p in deleteMiscOrderLocationDetailList
group p by p.Item into result
select new
{
Item = result.Key,
OrderdetId = result.FirstOrDefault().MiscOrderDetailId,
Count = result.Count()
};
var miscOrderDetailCount = from p in miscOrderLocationDetails
group p by p.Item into result
select new
{
Item = result.Key,
OrderdetId = result.FirstOrDefault().MiscOrderDetailId,
Count = result.Count()
};
var needToDeleteItems = from cc in deleteItemCount
from cd in miscOrderDetailCount
where cc.Item == cd.Item && cc.Count == cd.Count
select new
{
cc.Item,
cc.OrderdetId
};
if (deleteMiscOrderLocationDetailList != null && deleteMiscOrderLocationDetailList.Count > 0)
{
#region 数量处理
foreach (MiscOrderLocationDetail miscOrderLocationDetail in deleteMiscOrderLocationDetailList)
{
//删除locationdet
this.genericMgr.DeleteById<MiscOrderLocationDetail>(miscOrderLocationDetail.Id);
//this.genericMgr.Delete("from MiscOrderLocationDetail as l where l.MiscOrderDetailId=" + miscOrderDetail.Id);
}
#endregion
}
if ((needToDeleteItems != null && needToDeleteItems.ToList().Count() > 0))
{
foreach (var needToDeleteItem in needToDeleteItems.Select(p => new { p.Item, p.OrderdetId }).Distinct().ToList())
{
this.genericMgr.DeleteById<MiscOrderDetail>(needToDeleteItem.OrderdetId);
}
}
#endregion
}
[Transaction(TransactionMode.Requires)]
public void BatchUpdateMiscOrderDetails(string miscOrderNo,
IList<MiscOrderDetail> addMiscOrderDetailList, IList<MiscOrderDetail> updateMiscOrderDetailList, IList<MiscOrderDetail> deleteMiscOrderDetailList)
{
BatchUpdateMiscOrderDetails(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo), addMiscOrderDetailList, updateMiscOrderDetailList, deleteMiscOrderDetailList);
}
[Transaction(TransactionMode.Requires)]
public void BatchUpdateMiscOrderDetails(MiscOrderMaster miscOrderMaster,
IList<MiscOrderDetail> addMiscOrderDetailList, IList<MiscOrderDetail> updateMiscOrderDetailList, IList<MiscOrderDetail> deleteMiscOrderDetailList)
{
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Create)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
throw new BusinessException("计划外出库单{0}的状态为{1}不能修改明细。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
else
{
throw new BusinessException("计划外入库单{0}的状态为{1}不能修改明细。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
}
#region 新增计划外出入库明细
if (addMiscOrderDetailList != null && addMiscOrderDetailList.Count > 0)
{
#region 获取最大订单明细序号
string hql = "select max(Sequence) as seq from MiscOrderDetail where MiscOrderNo = ?";
IList<object> maxSeqList = genericMgr.FindAll<object>(hql, miscOrderMaster.MiscOrderNo);
int maxSeq = maxSeqList[0] != null ? (int)(maxSeqList[0]) : 0;
#endregion
#region 数量处理
foreach (MiscOrderDetail miscOrderDetail in addMiscOrderDetailList)
{
//Item item = this.genericMgr.FindById<Item>(miscOrderDetail.Item);
miscOrderDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo.ToUpper();
miscOrderDetail.Sequence = ++maxSeq;
//miscOrderDetail.Item = miscOrderDetail.Item;
//miscOrderDetail.ItemDescription = item.Description;
//miscOrderDetail.ReferenceItemCode = item.ReferenceCode;
//miscOrderDetail.Uom = miscOrderDetail.Uom;
//miscOrderDetail.BaseUom = item.Uom;
//miscOrderDetail.UnitCount = miscOrderDetail.UnitCount;
if (miscOrderDetail.Uom != miscOrderDetail.BaseUom)
{
miscOrderDetail.UnitQty = this.itemMgr.ConvertItemUomQty(miscOrderDetail.Item, miscOrderDetail.BaseUom, 1, miscOrderDetail.Uom);
}
else
{
miscOrderDetail.UnitQty = 1;
}
//miscOrderDetail.ReserveNo = miscOrderDetail.ReserveNo;
//miscOrderDetail.ReserveLine = miscOrderDetail.ReserveLine;
//miscOrderDetail.Qty = miscOrderDetail.Qty;
this.genericMgr.Create(miscOrderDetail);
if (miscOrderMaster.MiscOrderDetails == null)
{
miscOrderMaster.MiscOrderDetails = new List<MiscOrderDetail>();
}
//miscOrderMaster.MiscOrderDetails.Add(miscOrderDetail);
}
#endregion
}
#endregion
#region 修改计划外出入库明细
if (updateMiscOrderDetailList != null && updateMiscOrderDetailList.Count > 0)
{
foreach (MiscOrderDetail miscOrderDetail in updateMiscOrderDetailList)
{
if (miscOrderDetail.Uom != miscOrderDetail.BaseUom)
{
miscOrderDetail.UnitQty = this.itemMgr.ConvertItemUomQty(miscOrderDetail.Item, miscOrderDetail.BaseUom, 1, miscOrderDetail.Uom);
}
else
{
miscOrderDetail.UnitQty = 1;
}
this.genericMgr.Update(miscOrderDetail);
}
}
#endregion
#region 删除计划外出入库明细
if (deleteMiscOrderDetailList != null && deleteMiscOrderDetailList.Count > 0)
{
#region 数量处理
foreach (MiscOrderDetail miscOrderDetail in deleteMiscOrderDetailList)
{
//删除locationdet
this.genericMgr.Delete("from MiscOrderLocationDetail as l where l.MiscOrderDetailId=" + miscOrderDetail.Id);
this.genericMgr.Delete(miscOrderDetail);
}
#endregion
}
#endregion
}
[Transaction(TransactionMode.Requires)]
public void BatchUpdateMiscOrderDetails(string miscOrderNo, IList<string> addHuIdList, IList<string> deleteHuIdList)
{
BatchUpdateMiscOrderDetails(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo), addHuIdList, deleteHuIdList);
}
[Transaction(TransactionMode.Requires)]
public void BatchUpdateMiscOrderDetails(MiscOrderMaster miscOrderMaster, IList<string> addHuIdList, IList<string> deleteHuIdList)
{
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Create)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
throw new BusinessException("计划外出库单{0}的状态为{1}不能修改明细。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
else
{
throw new BusinessException("计划外入库单{0}的状态为{1}不能修改明细。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
}
TryLoadMiscOrderDetails(miscOrderMaster);
IList<MiscOrderLocationDetail> miscOrderLocationDetailList = TryLoadMiscOrderLocationDetails(miscOrderMaster);
#region 新增计划外出入库明细
if (addHuIdList != null && addHuIdList.Count > 0)
{
#region 获取最大订单明细序号
string hql = "select max(Sequence) as seq from MiscOrderDetail where MiscOrderNo = ?";
IList maxSeqList = genericMgr.FindAll(hql, miscOrderMaster.MiscOrderNo);
int maxSeq = maxSeqList != null && maxSeqList.Count > 0 && maxSeqList[0] != null ? (int)maxSeqList[0] : 0;
#endregion
#region 条码处理
#region 明细重复输入校验
#region 合并新增的HuId和原有的HuId
IList<string> huIdList = new List<string>();
((List<string>)huIdList).AddRange(addHuIdList);
if (miscOrderLocationDetailList != null && miscOrderLocationDetailList.Count > 0)
{
((List<string>)huIdList).AddRange(miscOrderLocationDetailList.Select(det => det.HuId).ToList());
}
#endregion
#region 检查是否重复
BusinessException businessException = new BusinessException();
var groupedHuIds = from huId in huIdList
group huId by huId into result
select new
{
HuId = result.Key,
Count = result.Count()
};
foreach (var groupedHuId in groupedHuIds.Where(g => g.Count > 1))
{
businessException = new BusinessException(string.Format("重复扫描条码{0}。", groupedHuId.HuId));
}
if (businessException.HasMessage)
{
throw businessException;
}
#endregion
#endregion
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
#region 计划外出库
#region 库存占用
IList<InventoryOccupy> inventoryOccupyList = (from huId in addHuIdList
select new InventoryOccupy
{
HuId = huId,
//Location = miscOrderMaster.Location, 不指定库位
QualityType = miscOrderMaster.QualityType,
OccupyType = CodeMaster.OccupyType.MiscOrder,
OccupyReferenceNo = miscOrderMaster.MiscOrderNo
}).ToList();
IList<LocationLotDetail> locationLotDetailList = this.locationDetailMgr.InventoryOccupy(inventoryOccupyList);
#endregion
#region 新增明细
foreach (LocationLotDetail locationLotDetail in locationLotDetailList)
{
MiscOrderDetail matchedMiscOrderDetail = null;
#region 明细处理
if (miscOrderMaster.MiscOrderDetails != null && miscOrderMaster.MiscOrderDetails.Count > 0)
{
//查找匹配的明细行
matchedMiscOrderDetail = miscOrderMaster.MiscOrderDetails.Where(det => det.Item == locationLotDetail.Item
&& det.Uom == locationLotDetail.HuUom
&& det.UnitCount == locationLotDetail.UnitCount
&& det.Location == locationLotDetail.Location).SingleOrDefault();
}
if (matchedMiscOrderDetail == null)
{
//没有找到明细行，新增明细
Item item = this.genericMgr.FindById<Item>(locationLotDetail.Item); //没有找到匹配的明细行，新增一行
matchedMiscOrderDetail = new MiscOrderDetail();
matchedMiscOrderDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo;
matchedMiscOrderDetail.Sequence = ++maxSeq;
matchedMiscOrderDetail.Item = locationLotDetail.Item;
matchedMiscOrderDetail.ItemDescription = item.Description;
matchedMiscOrderDetail.ReferenceItemCode = item.ReferenceCode;
matchedMiscOrderDetail.Uom = locationLotDetail.HuUom;
matchedMiscOrderDetail.BaseUom = locationLotDetail.BaseUom;
matchedMiscOrderDetail.UnitCount = locationLotDetail.UnitCount;
matchedMiscOrderDetail.UnitQty = locationLotDetail.UnitQty;
matchedMiscOrderDetail.Location = locationLotDetail.Location;
//matchedMiscOrderDetail.ReserveNo = addMiscOrderDetail.ReserveNo;
//matchedMiscOrderDetail.ReserveLine = addMiscOrderDetail.ReserveLine;
matchedMiscOrderDetail.Qty = locationLotDetail.Qty;
this.genericMgr.Create(matchedMiscOrderDetail);
miscOrderMaster.MiscOrderDetails.Add(matchedMiscOrderDetail);
}
else
{
//找到明细行，更新数量
matchedMiscOrderDetail.Qty += locationLotDetail.Qty;
this.genericMgr.Update(matchedMiscOrderDetail);
}
#endregion
#region 库存明细新增
MiscOrderLocationDetail miscOrderLocationDetail = new MiscOrderLocationDetail();
miscOrderLocationDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo;
miscOrderLocationDetail.MiscOrderDetailId = matchedMiscOrderDetail.Id;
miscOrderLocationDetail.MiscOrderDetailSequence = matchedMiscOrderDetail.Sequence;
miscOrderLocationDetail.Item = locationLotDetail.Item;
miscOrderLocationDetail.Uom = locationLotDetail.HuUom;
miscOrderLocationDetail.HuId = locationLotDetail.HuId;
miscOrderLocationDetail.LotNo = locationLotDetail.LotNo;
miscOrderLocationDetail.IsCreatePlanBill = false;
miscOrderLocationDetail.IsConsignment = locationLotDetail.IsConsignment;
miscOrderLocationDetail.PlanBill = locationLotDetail.PlanBill;
#region 查找寄售供应商
if (locationLotDetail.IsConsignment && locationLotDetail.PlanBill.HasValue)
{
miscOrderLocationDetail.ConsignmentSupplier = this.genericMgr.FindAll<string>("select Party from PlanBill where Id = ?", locationLotDetail.PlanBill.Value)[0];
}
#endregion
miscOrderLocationDetail.ActingBill = null;
miscOrderLocationDetail.QualityType = locationLotDetail.QualityType;
miscOrderLocationDetail.IsFreeze = locationLotDetail.IsFreeze;
miscOrderLocationDetail.IsATP = locationLotDetail.IsATP;
miscOrderLocationDetail.OccupyType = locationLotDetail.OccupyType;
miscOrderLocationDetail.OccupyReferenceNo = locationLotDetail.OccupyReferenceNo;
miscOrderLocationDetail.Qty = locationLotDetail.Qty;
if (addHuIdList.Contains(miscOrderLocationDetail.HuId))
{
this.genericMgr.Create(miscOrderLocationDetail);
}
#endregion
}
#endregion
#endregion
}
else
{
#region 计划外入库
#region 检查条码状态
IList<HuStatus> huStatusList = this.huMgr.GetHuStatus(addHuIdList);
foreach (string huId in addHuIdList)
{
HuStatus huStatus = huStatusList.Where(h => h.HuId == huId).SingleOrDefault();
if (huStatus == null)
{
businessException = new BusinessException(string.Format("条码{0}不存在。", huId));
}
else if (huStatus.Status == CodeMaster.HuStatus.Location)
{
businessException = new BusinessException(string.Format("条码{0}在库位{1}中，不能计划外入库。", huStatus.HuId, huStatus.Location));
}
else if (huStatus.Status == CodeMaster.HuStatus.Ip)
{
businessException = new BusinessException(string.Format("条码{0}为库位{1}至库位{2}的在途库存，不能计划外入库。", huStatus.HuId, huStatus.LocationFrom, huStatus.LocationTo));
}
}
if (businessException.HasMessage)
{
throw businessException;
}
#endregion
#region 新增明细
foreach (HuStatus huStatus in huStatusList)
{
MiscOrderDetail matchedMiscOrderDetail = null;
#region 明细处理
if (miscOrderMaster.MiscOrderDetails != null && miscOrderMaster.MiscOrderDetails.Count > 0)
{
//查找匹配的明细行
matchedMiscOrderDetail = miscOrderMaster.MiscOrderDetails
.Where(det => det.Item == huStatus.Item && det.Uom == huStatus.Uom && det.UnitCount == huStatus.UnitCount)
.SingleOrDefault();
}
if (matchedMiscOrderDetail == null)
{
//没有找到明细行，新增明细//没有找到匹配的明细行，新增一行
Item item = this.genericMgr.FindById<Item>(huStatus.Item);
matchedMiscOrderDetail = new MiscOrderDetail();
matchedMiscOrderDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo;
matchedMiscOrderDetail.Sequence = ++maxSeq;
matchedMiscOrderDetail.Item = huStatus.Item;
matchedMiscOrderDetail.ItemDescription = item.Description;
matchedMiscOrderDetail.ReferenceItemCode = item.ReferenceCode;
matchedMiscOrderDetail.Uom = huStatus.Uom;
matchedMiscOrderDetail.BaseUom = huStatus.BaseUom;
matchedMiscOrderDetail.UnitCount = huStatus.UnitCount;
matchedMiscOrderDetail.UnitQty = huStatus.UnitQty;
matchedMiscOrderDetail.ManufactureParty = huStatus.ManufactureParty;
//matchedMiscOrderDetail.Location =
//matchedMiscOrderDetail.ReserveNo = addMiscOrderDetail.ReserveNo;
//matchedMiscOrderDetail.ReserveLine = addMiscOrderDetail.ReserveLine;
matchedMiscOrderDetail.Qty = huStatus.Qty;
this.genericMgr.Create(matchedMiscOrderDetail);
miscOrderMaster.MiscOrderDetails.Add(matchedMiscOrderDetail);
}
else
{
//找到明细行，更新数量
matchedMiscOrderDetail.Qty += huStatus.Qty;
this.genericMgr.Update(matchedMiscOrderDetail);
}
#endregion
#region 库存明细新增
MiscOrderLocationDetail miscOrderLocationDetail = new MiscOrderLocationDetail();
miscOrderLocationDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo;
miscOrderLocationDetail.MiscOrderDetailId = matchedMiscOrderDetail.Id;
miscOrderLocationDetail.MiscOrderDetailSequence = matchedMiscOrderDetail.Sequence;
miscOrderLocationDetail.Item = huStatus.Item;
miscOrderLocationDetail.Uom = huStatus.Uom;
miscOrderLocationDetail.HuId = huStatus.HuId;
miscOrderLocationDetail.LotNo = huStatus.LotNo;
miscOrderLocationDetail.IsCreatePlanBill = false;
miscOrderLocationDetail.IsConsignment = false;
miscOrderLocationDetail.PlanBill = null;
miscOrderLocationDetail.ConsignmentSupplier = null;
miscOrderLocationDetail.ActingBill = null;
miscOrderLocationDetail.QualityType = huStatus.QualityType;
miscOrderLocationDetail.IsFreeze = false;
miscOrderLocationDetail.IsATP = true;
miscOrderLocationDetail.OccupyType = CodeMaster.OccupyType.None;
miscOrderLocationDetail.OccupyReferenceNo = null;
miscOrderLocationDetail.Qty = huStatus.Qty * huStatus.UnitQty;
this.genericMgr.Create(miscOrderLocationDetail);
#endregion
}
#endregion
#endregion
}
#endregion
}
#endregion
#region 删除计划外出入库明细
if (deleteHuIdList != null && deleteHuIdList.Count > 0)
{
#region 条码处理
#region 条码是否在计划外出入库单中存在检查
BusinessException businessException = new BusinessException();
foreach (string huId in deleteHuIdList)
{
if (miscOrderLocationDetailList == null || miscOrderLocationDetailList.Where(m => m.HuId == huId).Count() == 0)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
businessException.AddMessage("条码{0}在计划外出库单{1}中不存在。", huId, miscOrderMaster.MiscOrderNo);
}
else
{
businessException.AddMessage("条码{0}在计划外入库单{1}中不存在。", huId, miscOrderMaster.MiscOrderNo);
}
}
}
if (businessException.HasMessage)
{
throw businessException;
}
#endregion
#region 循环删除
#region 取消占用
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
this.locationDetailMgr.CancelInventoryOccupy(CodeMaster.OccupyType.MiscOrder, miscOrderMaster.MiscOrderNo, deleteHuIdList);
}
#endregion
foreach (string huId in deleteHuIdList)
{
#region 扣减明细数量，删除库存明细
MiscOrderLocationDetail miscOrderLocationDetail = miscOrderLocationDetailList.Where(det => det.HuId == huId).Single();
MiscOrderDetail miscOrderDetail = miscOrderMaster.MiscOrderDetails.Where(det => det.Id == miscOrderLocationDetail.MiscOrderDetailId).Single();
miscOrderDetail.Qty -= miscOrderLocationDetail.Qty / miscOrderDetail.UnitQty;
this.genericMgr.Update(miscOrderDetail);
this.genericMgr.Delete(miscOrderLocationDetail);
#endregion
}
#endregion
#endregion
}
#endregion
}
[Transaction(TransactionMode.Requires)]
public void DeleteMiscOrder(string miscOrderNo)
{
this.DeleteMiscOrder(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo));
}
[Transaction(TransactionMode.Requires)]
public void DeleteMiscOrder(MiscOrderMaster miscOrderMaster)
{
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Create)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
throw new BusinessException("计划外出库单{0}的状态为{1}不能删除。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
else
{
throw new BusinessException("计划外入库单{0}的状态为{1}不能删除。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
}
if (miscOrderMaster.IsScanHu)
{
IList<MiscOrderLocationDetail> miscOrderLocationDetailList = TryLoadMiscOrderLocationDetails(miscOrderMaster);
if (miscOrderLocationDetailList != null && miscOrderLocationDetailList.Count > 0)
{
this.genericMgr.Delete<MiscOrderLocationDetail>(miscOrderLocationDetailList);
}
}
IList<MiscOrderDetail> miscOrderDetailList = TryLoadMiscOrderDetails(miscOrderMaster);
if (miscOrderDetailList != null && miscOrderDetailList.Count > 0)
{
this.genericMgr.Delete<MiscOrderDetail>(miscOrderDetailList);
}
this.genericMgr.Delete(miscOrderMaster);
}
[Transaction(TransactionMode.Requires)]
public void CloseMiscOrder(string miscOrderNo)
{
this.CloseMiscOrder(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo));
}
[Transaction(TransactionMode.Requires)]
public void CloseMiscOrder(string miscOrderNo, DateTime effectiveDate)
{
this.CloseMiscOrder(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo), effectiveDate);
}
[Transaction(TransactionMode.Requires)]
public void CloseMiscOrder(MiscOrderMaster miscOrderMaster)
{
this.CloseMiscOrder(miscOrderMaster, miscOrderMaster.EffectiveDate);
}
[Transaction(TransactionMode.Requires)]
public void CloseMiscOrder(MiscOrderMaster miscOrderMaster, DateTime effectiveDate)
{
#region 检查
BusinessException businessException = new BusinessException();
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Create)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
businessException.AddMessage("计划外出库单{0}的状态为{1}不能确认。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
else
{
businessException.AddMessage("计划外入库单{0}的状态为{1}不能确认。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
}
IList<MiscOrderDetail> miscOrderDetailList = TryLoadMiscOrderDetails(miscOrderMaster);
if (miscOrderDetailList == null || miscOrderDetailList.Count() == 0)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
businessException.AddMessage("计划外出库单{0}明细为空。", miscOrderMaster.MiscOrderNo);
}
else
{
businessException.AddMessage("计划外入库单{0}明细为空。", miscOrderMaster.MiscOrderNo);
}
}
else
{
foreach (MiscOrderDetail miscOrderDetail in miscOrderDetailList)
{
if (miscOrderDetail.Qty <= 0)
{
businessException.AddMessage("计划外入库单{0}明细行{1}的数量不能小于0。", miscOrderMaster.MiscOrderNo, miscOrderDetail.Sequence.ToString());
}
}
}
if (businessException.HasMessage)
{
throw businessException;
}
#endregion
User user = SecurityContextHolder.Get();
miscOrderMaster.CloseDate = DateTime.Now;
miscOrderMaster.CloseUserId = user.Id;
miscOrderMaster.CloseUserName = user.FullName;
miscOrderMaster.Status = com.Sconit.CodeMaster.MiscOrderStatus.Close;
this.genericMgr.Update(miscOrderMaster);
//后加工废品报工不影响库存
if (miscOrderMaster.SubType == CodeMaster.MiscOrderSubType.MES27)
{
return;
}
//
IList<MiscOrderLocationDetail> miscOrderLocationDetailList = TryLoadMiscOrderLocationDetails(miscOrderMaster);
foreach (MiscOrderDetail miscOrderDetail in miscOrderDetailList.OrderByDescending(det => det.ManufactureParty))
{
miscOrderDetail.ManufactureParty = miscOrderMaster.IsCs ? miscOrderDetail.ManufactureParty : null;
IList<InventoryTransaction> inventoryTransactionList = this.locationDetailMgr.InventoryOtherInOut(miscOrderMaster, miscOrderDetail, effectiveDate);
#region 新增、更新订单库存明细
foreach (InventoryTransaction inventoryTransaction in inventoryTransactionList)
{
if (miscOrderMaster.IsScanHu)
{
#region 条码
MiscOrderLocationDetail miscOrderLocationDetail = miscOrderLocationDetailList.Where(m => m.HuId == inventoryTransaction.HuId).Single();
if (inventoryTransaction.ActingBill.HasValue)
{
miscOrderLocationDetail.IsConsignment = false;
miscOrderLocationDetail.PlanBill = null;
miscOrderLocationDetail.ActingBill = inventoryTransaction.ActingBill;
}
this.genericMgr.Update(miscOrderLocationDetail);
#endregion
}
else
{
#region 数量
MiscOrderLocationDetail miscOrderLocationDetail = new MiscOrderLocationDetail();
miscOrderLocationDetail.MiscOrderNo = miscOrderMaster.MiscOrderNo;
miscOrderLocationDetail.MiscOrderDetailId = miscOrderDetail.Id;
miscOrderLocationDetail.MiscOrderDetailSequence = miscOrderDetail.Sequence;
miscOrderLocationDetail.Item = inventoryTransaction.Item;
miscOrderLocationDetail.Uom = miscOrderDetail.Uom;
//miscOrderLocationDetail.HuId = locationLotDetail.HuId;
//miscOrderLocationDetail.LotNo = locationLotDetail.LotNo;
miscOrderLocationDetail.IsCreatePlanBill = inventoryTransaction.IsCreatePlanBill;
miscOrderLocationDetail.IsConsignment = inventoryTransaction.IsConsignment;
miscOrderLocationDetail.PlanBill = inventoryTransaction.PlanBill;
#region 查找寄售供应商
if (inventoryTransaction.IsConsignment && inventoryTransaction.PlanBill.HasValue)
{
miscOrderLocationDetail.ConsignmentSupplier = this.genericMgr.FindAll<string>("select Party from PlanBill where Id = ?", inventoryTransaction.PlanBill.Value).Single();
}
#endregion
miscOrderLocationDetail.ActingBill = null;
miscOrderLocationDetail.QualityType = inventoryTransaction.QualityType;
miscOrderLocationDetail.IsFreeze = inventoryTransaction.IsFreeze;
miscOrderLocationDetail.IsATP = inventoryTransaction.IsATP;
miscOrderLocationDetail.OccupyType = inventoryTransaction.OccupyType;
miscOrderLocationDetail.OccupyReferenceNo = inventoryTransaction.OccupyReferenceNo;
miscOrderLocationDetail.Qty = inventoryTransaction.Qty;
this.genericMgr.Create(miscOrderLocationDetail);
#endregion
}
}
#endregion
}
}
[Transaction(TransactionMode.Requires)]
public void CancelMiscOrder(string miscOrderNo)
{
CancelMiscOrder(miscOrderNo, DateTime.Now);
}
[Transaction(TransactionMode.Requires)]
public void CancelMiscOrder(string miscOrderNo, DateTime effectiveDate)
{
this.CancelMiscOrder(this.genericMgr.FindById<MiscOrderMaster>(miscOrderNo), effectiveDate);
}
[Transaction(TransactionMode.Requires)]
public void CancelMiscOrder(MiscOrderMaster miscOrderMaster)
{
this.CancelMiscOrder(miscOrderMaster, DateTime.Now);
}
[Transaction(TransactionMode.Requires)]
public void CancelMiscOrder(MiscOrderMaster miscOrderMaster, DateTime effectiveDate)
{
effectiveDate = miscOrderMaster.EffectiveDate;
if (miscOrderMaster.Status != CodeMaster.MiscOrderStatus.Close)
{
if (miscOrderMaster.Type == CodeMaster.MiscOrderType.GI)
{
throw new BusinessException("计划外出库单{0}的状态为{1}不能冲销。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
else
{
throw new BusinessException("计划外入库单{0}的状态为{1}不能冲销。",
miscOrderMaster.MiscOrderNo, systemMgr.GetCodeDetailDescription(com.Sconit.CodeMaster.CodeMaster.MiscOrderStatus, ((int)miscOrderMaster.Status).ToString()));
}
}
TryLoadMiscOrderLocationDetails(miscOrderMaster);
User user = SecurityContextHolder.Get();
miscOrderMaster.CancelDate = DateTime.Now;
miscOrderMaster.CancelUserId = user.Id;
miscOrderMaster.CancelUserName = user.FullName;
miscOrderMaster.Status = com.Sconit.CodeMaster.MiscOrderStatus.Cancel;
this.genericMgr.Update(miscOrderMaster);
//后加工废品报工不影响库存
if (miscOrderMaster.SubType == CodeMaster.MiscOrderSubType.MES27)
{
return;
}
//
this.locationDetailMgr.CancelInventoryOtherInOut(miscOrderMaster, effectiveDate);
}
[Transaction(TransactionMode.Requires)]
public void Import201202MiscOrder(Stream inputStream, string wMSNo, string moveTypeSet, string cancelMoveTypeSet, string miscType)
{
#region 导入数据
if (inputStream.Length == 0)
{
throw new BusinessException("Import.Stream.Empty");
}
HSSFWorkbook workbook = new HSSFWorkbook(inputStream);
ISheet sheet = workbook.GetSheetAt(0);
IEnumerator rows = sheet.GetRowEnumerator();
ImportHelper.JumpRows(rows, 10);
#region 列定义
int colMoveType = 1;//移动类型
//int colEffectiveDate = 2;//生效日期
//int colRegion = 3;//区域
int colLocation = 2;//库位
//int colReferenceNo = 5;//Sap订单号
int colItem = 3;//物料编号
int colQty = 4;//数量
int colCostCenter = 5;//成本中心
DateTime? prevEffeDate = null;
string prevRegion = string.Empty;
#endregion
BusinessException businessException = new BusinessException();
int rowCount = 10;
IList<MiscOrderDetail> activeDetailList = new List<MiscOrderDetail>();
IList<MiscOrderMaster> activeMasterList = new List<MiscOrderMaster>();
IList<Region> regionList = this.genericMgr.FindAll<Region>();
IList<Item> itemList = this.genericMgr.FindAll<Item>();
IList<Location> locationList = this.genericMgr.FindAll<Location>();
IList<Location> adjustocationList = this.genericMgr.FindAll<Location>();
IList<CostCenter> costCenterList = this.genericMgr.FindAll<CostCenter>();
//调整单Check库位权限
User user = SecurityContextHolder.Get();
string sql = @"select * from MD_Location as l where Code in(select distinct(LocFrom) from SCM_FlowMstr where type=4)
and l.IsActive = ?";
IList<object> paramList = new List<object>();
paramList.Add(true);
sql += " order by LEN(Code),Code ";
adjustocationList = genericMgr.FindEntityWithNativeSql<Location>(sql, paramList.ToArray())
.Where(p => user.RegionPermissions.Contains(p.Region)).ToList();
//
while (rows.MoveNext())
{
rowCount++;
HSSFRow row = (HSSFRow)rows.Current;
if (!ImportHelper.CheckValidDataRow(row, 1, 9))
{
break;//边界
}
string moveType = string.Empty;
DateTime effectiveDate = System.DateTime.Now;
string regionCode = string.Empty;
string locationCode = string.Empty;
string costCenterCode = string.Empty;
string referenceNo = string.Empty;
string itemCode = string.Empty;
decimal qty = 0;
Item item = new Item();
#region 读取数据
#region 移动类型
moveType = ImportHelper.GetCellStringValue(row.GetCell(colMoveType));
if (string.IsNullOrWhiteSpace(moveType))
{
businessException.AddMessage(string.Format("第{0}行:移动类型不能为空。", rowCount));
}
else
{
if (moveType != moveTypeSet && moveType != cancelMoveTypeSet)
{
businessException.AddMessage(string.Format("第{0}行:移动类型{1}填写有误，只能填{2}、{3}。", rowCount, moveType, moveTypeSet, cancelMoveTypeSet));
}
}
#endregion
//#region 生效日期
//string readEffectiveDate = ImportHelper.GetCellStringValue(row.GetCell(colEffectiveDate));
//if (string.IsNullOrWhiteSpace(readEffectiveDate))
//{
// businessException.AddMessage(string.Format("第{0}行:生效日期不能为空。", rowCount));
//}
//else
//{
// if (!DateTime.TryParse(readEffectiveDate, out effectiveDate))
// {
// businessException.AddMessage(string.Format("第{0}行:生效日期{1}填写有误.", rowCount, moveType));
// continue;
// }
// if (prevEffeDate != null)
// {
// if (prevEffeDate.Value != effectiveDate)
// {
// businessException.AddMessage(string.Format("第{0}行:生效日期{1}与前一行生效日期{2}不同。", rowCount, effectiveDate, prevEffeDate.Value));
// continue;
// }
// }
// prevEffeDate = effectiveDate;
//}
//#endregion
//#region 区域
//regionCode = ImportHelper.GetCellStringValue(row.GetCell(colRegion));
//if (string.IsNullOrWhiteSpace(regionCode))
//{
// businessException.AddMessage(string.Format("第{0}行:区域不能为空。", rowCount));
//}
//else
//{
// if (string.IsNullOrWhiteSpace(prevRegion))
// {
// var regions = regionList.Where(l => l.Code == regionCode).ToList();
// if (regions == null || regions.Count == 0)
// {
// businessException.AddMessage(string.Format("第{0}行:区域{1}填写有误.", rowCount, regionCode));
// }
// }
// else
// {
// if (regionCode != prevRegion)
// {
// businessException.AddMessage(string.Format("第{0}行:区域{1}与前一行区域{2}不同。", rowCount, regionCode, prevRegion));
// continue;
// }
// }
// prevRegion = regionCode;
//}
//#endregion
#region 读取库位
locationCode = ImportHelper.GetCellStringValue(row.GetCell(colLocation));
if (!string.IsNullOrEmpty(locationCode))
{
var locations = locationList.Where(l => l.Code == locationCode).ToList();
if (locations == null || locations.Count == 0)
{
businessException.AddMessage(string.Format("第{0}行:库位{1}不存在。", rowCount, locationCode));
}
//else if (locations.First().Region != regionCode)
//{
// businessException.AddMessage(string.Format("第{0}行:区域{1}不存在库位{2}。", rowCount, regionCode, locationCode));
//}
else
{
regionCode = locations[0].Region;
}
if (miscType == "AdjustOrder")
{
var adjustlocations = adjustocationList.Where(l => l.Code == locationCode).ToList();
if (adjustlocations == null || adjustlocations.Count == 0)
{
businessException.AddMessage(string.Format("第{0}行:用户没有调整库位{1}的权限。", rowCount, locationCode));
}
}
}
else
{
//businessException.AddMessage(string.Format("第{0}行:区域不能为空。", rowCount));
}
#endregion
#region 成本中心
costCenterCode = ImportHelper.GetCellStringValue(row.GetCell(colCostCenter));
if (!string.IsNullOrEmpty(costCenterCode))
{
var costCenters = costCenterList.Where(l => l.Code == costCenterCode).ToList();
if (costCenters == null || costCenters.Count == 0)
{
businessException.AddMessage(string.Format("第{0}行:成本中心{1}不存在。", rowCount, costCenterCode));
}
else
{
costCenterCode = costCenters.ToList().FirstOrDefault().Code;
}
//else if (locations.First().Region != regionCode)
//{
// businessException.AddMessage(string.Format("第{0}行:区域{1}不存在库位{2}。", rowCount, regionCode, locationCode));
//}
}
else if (moveTypeSet == "201")
{
businessException.AddMessage(string.Format("第{0}行:成本中心不能为空。", rowCount));
}
#endregion
//#region Sap订单号
//referenceNo = ImportHelper.GetCellStringValue(row.GetCell(colReferenceNo));
//if (string.IsNullOrEmpty(referenceNo))
//{
// businessException.AddMessage(string.Format("第{0}行:Sap订单号不能为空。", rowCount));
//}
//else
//{
// //if (this.genericMgr.FindAllWithNativeSql<int>("select count(*) from SAP_ProdBomDet where AUFNR=? ", referenceNo.PadLeft(12, '0'))[0] == 0)
// //{
// // businessException.AddMessage(string.Format("第{0}行:Sap订单号不存在ORD_OrderMstr_4表中。", rowCount));
// //}
//}
//#endregion
#region 物料编号
itemCode = ImportHelper.GetCellStringValue(row.GetCell(colItem));
if (string.IsNullOrWhiteSpace(itemCode))
{
businessException.AddMessage(string.Format("第{0}行:物料编号不能为空。", rowCount));
}
else
{
var items = itemList.Where(l => l.Code == itemCode).ToList();
if (items == null || items.Count == 0)
{
businessException.AddMessage(string.Format("第{0}行:物料编号{1}不存在.", rowCount, itemCode));
}
else
{
item = items.First();
}
}
#endregion
#region 数量
string readQty = ImportHelper.GetCellStringValue(row.GetCell(colQty));
if (string.IsNullOrEmpty(readQty))
{
businessException.AddMessage(string.Format("第{0}行:数量不能为空。", rowCount));
}
else
{
decimal.TryParse(readQty, out qty);
if (qty <= 0)
{
businessException.AddMessage(string.Format("第{0}行:数量{1}只能为大于等于0的数字。", rowCount, readQty));
}
}
#endregion
#endregion
#region 填充数据
if (!businessException.HasMessage)
{
MiscOrderDetail miscOrderDetail = new MiscOrderDetail();
miscOrderDetail.MoveType = moveType;
miscOrderDetail.EffectiveDate = effectiveDate;
miscOrderDetail.Location = locationCode;
miscOrderDetail.Region = regionCode;
miscOrderDetail.Item = item.Code;
miscOrderDetail.ItemDescription = item.Description;
miscOrderDetail.ReferenceItemCode = item.ReferenceCode;
miscOrderDetail.Uom = item.Uom;
miscOrderDetail.BaseUom = item.Uom;
miscOrderDetail.UnitCount = item.UnitCount;
miscOrderDetail.Qty = qty;
miscOrderDetail.CostCenter = costCenterCode;
activeDetailList.Add(miscOrderDetail);
}
#endregion
}
if (businessException.HasMessage)
{
throw businessException;
}
if (activeDetailList.Count == 0)
{
throw new BusinessException("导入的有效数据为0，请确实。");
}
//Merge details
//201一张单
var allLocation = activeDetailList.Select(p => p.Location).Distinct();
foreach (var location in allLocation)
{
var outDetail = activeDetailList.Where(a => a.MoveType == moveTypeSet && a.Location == (string)location).ToList();
if (outDetail != null && outDetail.Count > 0)
{
MiscOrderDetail fisrDet = outDetail.First();
MiscOrderMoveType miscOrderMoveType = genericMgr.FindAll<MiscOrderMoveType>("from MiscOrderMoveType as m where m.MoveType =? ", moveTypeSet)[0];
MiscOrderMaster miscMaster = new MiscOrderMaster();
miscMaster.Type = miscOrderMoveType.IOType;
miscMaster.MoveType = miscOrderMoveType.MoveType;
miscMaster.CancelMoveType = miscOrderMoveType.CancelMoveType;
miscMaster.Location = fisrDet.Location;
miscMaster.Region = fisrDet.Region;
miscMaster.EffectiveDate = fisrDet.EffectiveDate;
miscMaster.IsScanHu = false;
miscMaster.ReferenceNo = null;
miscMaster.MiscOrderDetails = outDetail;
miscMaster.WMSNo = wMSNo; //备注
miscMaster.CostCenter = fisrDet.CostCenter;
miscMaster.SubType = miscType == "AdjustOrder" ? CodeMaster.MiscOrderSubType.SY05 : CodeMaster.MiscOrderSubType.COST;
activeMasterList.Add(miscMaster);
}
//202 一张单
var inDetail = activeDetailList.Where(a => a.MoveType == cancelMoveTypeSet && a.Location == (string)location).ToList();
if (inDetail != null && inDetail.Count > 0)
{
MiscOrderDetail fisrInDet = inDetail.First();
MiscOrderMoveType miscOrderInMoveType = genericMgr.FindAll<MiscOrderMoveType>("from MiscOrderMoveType as m where m.MoveType =? ", cancelMoveTypeSet)[0];
var inMiscOrder = new MiscOrderMaster();
inMiscOrder.Type = miscOrderInMoveType.IOType;
inMiscOrder.MoveType = miscOrderInMoveType.MoveType;
inMiscOrder.CancelMoveType = miscOrderInMoveType.CancelMoveType;
inMiscOrder.Location = fisrInDet.Location;
inMiscOrder.Region = fisrInDet.Region;
inMiscOrder.EffectiveDate = fisrInDet.EffectiveDate;
inMiscOrder.IsScanHu = false;
inMiscOrder.ReferenceNo = null;
inMiscOrder.MiscOrderDetails = inDetail;
inMiscOrder.WMSNo = wMSNo; //备注
inMiscOrder.CostCenter = fisrInDet.CostCenter;
inMiscOrder.SubType = miscType == "AdjustOrder" ? CodeMaster.MiscOrderSubType.SY05 : CodeMaster.MiscOrderSubType.COST;
activeMasterList.Add(inMiscOrder);
}
}
if (businessException.HasMessage)
{
throw businessException;
}
string message = "生成单号";
foreach (var master in activeMasterList)
{
master.QualityType = com.Sconit.CodeMaster.QualityType.Qualified;
activeDetailList = (from p in master.MiscOrderDetails
group p by new
{
p.Item,
p.ItemDescription,
p.ReferenceItemCode,
p.Uom,
p.BaseUom,
p.UnitCount,
p.Location
} into g
select new MiscOrderDetail
{
Sequence = g.Max(p => p.Sequence),
Item = g.Key.Item,
ItemDescription = g.Key.ItemDescription,
ReferenceItemCode = g.Key.ReferenceItemCode,
Uom = g.Key.Uom,
BaseUom = g.Key.BaseUom,
UnitCount = g.Key.UnitCount,
UnitQty = 1,
Location = g.Key.Location,
Qty = g.Sum(p => p.Qty),
}).ToList();
master.MiscOrderDetails = new List<MiscOrderDetail>();
this.CreateMiscOrder(master);
BatchUpdateMiscOrderDetails(master, activeDetailList, null, null);
this.genericMgr.FlushSession();
master.MiscOrderDetails = null;
//CloseMiscOrder(master, master.EffectiveDate);
message += " " + master.MiscOrderNo + ";";
}
MessageHolder.AddMessage(new Message(CodeMaster.MessageType.Info, message));
#endregion
}
[Transaction(TransactionMode.Requires)]
public void CreateMiscOrderDetailFromXls(Stream inputStream, string miscOrderNo)
{
//导入的话以导入的为准，之前的全部干掉
#region 清空明细
string hql = @"from MiscOrderDetail as m where m.MiscOrderNo = ?";
genericMgr.Delete(hql, new object[] { miscOrderNo }, new IType[] { NHibernateUtil.String });
#endregion
MiscOrderMaster miscOrder = genericMgr.FindById<MiscOrderMaster>(miscOrderNo);
#region 导入数据
if (inputStream.Length == 0)
{
throw new BusinessException("Import.Stream.Empty");
}
HSSFWorkbook workbook = new HSSFWorkbook(inputStream);
ISheet sheet = workbook.GetSheetAt(0);
IEnumerator rows = sheet.GetRowEnumerator();
ImportHelper.JumpRows(rows, 11);
#region 列定义
int colItem = 1;//物料代码
//int colUom = 3;//单位
int colLocation = 2;//库位
int colQty = 3;//数量
int colReverseLine = 4;//预留行
int colReverseNo = 5;//预留号
#endregion
DateTime dateTimeNow = DateTime.Now;
IList<MiscOrderDetail> miscOrderDetailList = new List<MiscOrderDetail>();
while (rows.MoveNext())
{
HSSFRow row = (HSSFRow)rows.Current;
if (!ImportHelper.CheckValidDataRow(row, 1, 9))
{
break;//边界
}
string itemCode = string.Empty;
decimal qty = 0;
string uomCode = string.Empty;
string locationCode = string.Empty;
string reverseLine = string.Empty;
string reverseNo = string.Empty;
#region 读取数据
#region 读取物料代码
itemCode = ImportHelper.GetCellStringValue(row.GetCell(colItem));
if (itemCode == null || itemCode.Trim() == string.Empty)
{
ImportHelper.ThrowCommonError(row.RowNum, colItem, row.GetCell(colItem));
}
#endregion
//#region 读取单位
//uomCode = row.GetCell(colUom) != null ? row.GetCell(colUom).StringCellValue : string.Empty;
//if (uomCode == null || uomCode.Trim() == string.Empty)
//{
// throw new BusinessException("Import.Read.Error.Empty", (row.RowNum + 1).ToString(), colUom.ToString());
//}
//#endregion
#endregion
#region 读取库位
locationCode = row.GetCell(colLocation) != null ? row.GetCell(colLocation).StringCellValue : string.Empty;
if (string.IsNullOrEmpty(locationCode))
{
throw new BusinessException("Import.Read.Error.Empty", (row.RowNum + 1).ToString(), locationCode.ToString());
}
Location location = genericMgr.FindById<Location>(locationCode);
//if (location.Region != miscOrder.Region)
//{
// throw new BusinessException("指定区域不存在此库位" + location, (row.RowNum + 1).ToString(), colLocation.ToString());
//}
#endregion
#region 读取数量
try
{
qty = decimal.Parse(ImportHelper.GetCellStringValue(row.GetCell(colQty)));
}
catch
{
ImportHelper.ThrowCommonError(row.RowNum, colQty, row.GetCell(colQty));
}
#endregion
#region
MiscOrderMoveType miscOrderMoveType = genericMgr.FindAll<MiscOrderMoveType>("from MiscOrderMoveType as m where m.MoveType=? and m.IOType=?", new object[] { miscOrder.MoveType, miscOrder.Type })[0];
if (miscOrderMoveType.CheckReserveLine)
{
reverseLine = row.GetCell(colReverseLine) != null ? row.GetCell(colReverseLine).StringCellValue : string.Empty;
//if (reverseLine == null || reverseLine.Trim() == string.Empty)
//{
// throw new BusinessException("Import.Read.Error.Empty", (row.RowNum + 1).ToString(), colUom.ToString());
//}
}
if (miscOrderMoveType.CheckReserveNo)
{
reverseNo = row.GetCell(colReverseNo) != null ? row.GetCell(colReverseNo).StringCellValue : string.Empty;
//if (reverseNo == null || reverseNo.Trim() == string.Empty)
//{
// throw new BusinessException("Import.Read.Error.Empty", (row.RowNum + 1).ToString(), colUom.ToString());
//}
}
#endregion
#region 填充数据
MiscOrderDetail mod = new MiscOrderDetail();
Item item = genericMgr.FindById<Item>(itemCode);
mod.Location = locationCode;
mod.Item = itemCode;
mod.Uom = item.Uom;
mod.ItemDescription = item.Description;
mod.BaseUom = item.Uom;
mod.Qty = qty;
mod.ReserveLine = reverseLine;
mod.ReserveNo = reverseNo;
miscOrderDetailList.Add(mod);
#endregion
}
#endregion
#region 新增明细
CreateMiscOrderDetail(miscOrderDetailList, miscOrder.MiscOrderNo);
#endregion
}
[Transaction(TransactionMode.Requires)]
public void QuickCreateMiscOrder(IList<string> addHuIdList, string locationCode, string binCode, int type)
{
MiscOrderMaster miscOrderMaster = new MiscOrderMaster();
miscOrderMaster.MiscOrderNo = this.numberControlMgr.GetMiscOrderNo(miscOrderMaster);
miscOrderMaster.EffectiveDate = DateTime.Now;
miscOrderMaster.QualityType = CodeMaster.QualityType.Qualified;
miscOrderMaster.IsScanHu = true;
miscOrderMaster.CreateDate = DateTime.Now;
User user = SecurityContextHolder.Get();
miscOrderMaster.CreateUserId = user.Id;
miscOrderMaster.CreateUserName = user.Name;
if (type == 1)
{
MiscOrderMoveType moveType = genericMgr.FindAll<MiscOrderMoveType>("from MiscOrderMoveType as m where m.MoveType=? and m.IOType=?", new object[] { "101", type })[0];
miscOrderMaster.Type = CodeMaster.MiscOrderType.GR;
miscOrderMaster.MoveType = moveType.MoveType;
miscOrderMaster.CancelMoveType = moveType.CancelMoveType;
if (!string.IsNullOrEmpty(binCode))
{
LocationBin bin = genericMgr.FindById<LocationBin>(binCode);
Location location = genericMgr.FindById<Location>(bin.Location);
miscOrderMaster.Location = bin.Location;
miscOrderMaster.Region = location.Region;
}
else if (!string.IsNullOrEmpty(locationCode))
{
Location location = genericMgr.FindById<Location>(locationCode);
miscOrderMaster.Location = location.Code;
miscOrderMaster.Region = location.Region;
}
}
else
{
MiscOrderMoveType moveType = genericMgr.FindAll<MiscOrderMoveType>("from MiscOrderMoveType as m where m.MoveType=? and m.IOType=?", new object[] { "102", type })[0];
miscOrderMaster.Type = CodeMaster.MiscOrderType.GI;
miscOrderMaster.MoveType = moveType.MoveType;
miscOrderMaster.CancelMoveType = moveType.CancelMoveType;
Location location = genericMgr.FindById<Location>(locationCode);
miscOrderMaster.Location = location.Code;
miscOrderMaster.Region = location.Region;
}
this.CreateMiscOrder(miscOrderMaster);
BatchUpdateMiscOrderDetails(miscOrderMaster, addHuIdList, null);
this.genericMgr.FlushSession();
CloseMiscOrder(miscOrderMaster.MiscOrderNo);
#region 上架
if (type == 1 && !string.IsNullOrEmpty(binCode))
{
var inventoryPutList = new List<Entity.INV.InventoryPut>();
foreach (var huId in addHuIdList)
{
var inventoryPut = new Entity.INV.InventoryPut();
inventoryPut.Bin = binCode;
inventoryPut.HuId = huId;
inventoryPutList.Add(inventoryPut);
}
this.locationDetailMgr.InventoryPut(inventoryPutList);
}
#endregion
}
private IList<MiscOrderDetail> TryLoadMiscOrderDetails(MiscOrderMaster miscOrderMaster)
{
if (!string.IsNullOrWhiteSpace(miscOrderMaster.MiscOrderNo))
{
if (miscOrderMaster.MiscOrderDetails == null)
{
string hql = "from MiscOrderDetail where MiscOrderNo = ? order by Sequence";
miscOrderMaster.MiscOrderDetails = this.genericMgr.FindAll<MiscOrderDetail>(hql, miscOrderMaster.MiscOrderNo);
}
return miscOrderMaster.MiscOrderDetails;
}
else
{
return null;
}
}
private IList<MiscOrderLocationDetail> TryLoadMiscOrderLocationDetails(MiscOrderMaster miscOrderMaster)
{
if (miscOrderMaster.MiscOrderNo != null)
{
TryLoadMiscOrderDetails(miscOrderMaster);
IList<MiscOrderLocationDetail> miscOrderLocationDetailList = new List<MiscOrderLocationDetail>();
string hql = string.Empty;
IList<object> para = new List<object>();
foreach (MiscOrderDetail miscOrderDetail in miscOrderMaster.MiscOrderDetails)
{
if (miscOrderDetail.MiscOrderLocationDetails != null && miscOrderDetail.MiscOrderLocationDetails.Count > 0)
{
((List<MiscOrderLocationDetail>)miscOrderLocationDetailList).AddRange(miscOrderDetail.MiscOrderLocationDetails);
}
else
{
if (hql == string.Empty)
{
hql = "from MiscOrderLocationDetail where MiscOrderDetailId in (?";
}
else
{
hql += ",?";
}
para.Add(miscOrderDetail.Id);
}
}
if (hql != string.Empty)
{
hql += ") order by MiscOrderDetailId";
((List<MiscOrderLocationDetail>)miscOrderLocationDetailList).AddRange(this.genericMgr.FindAll<MiscOrderLocationDetail>(hql, para.ToArray()));
}
foreach (MiscOrderDetail miscOrderDetail in miscOrderMaster.MiscOrderDetails)
{
if (miscOrderDetail.MiscOrderLocationDetails == null || miscOrderDetail.MiscOrderLocationDetails.Count == 0)
{
miscOrderDetail.MiscOrderLocationDetails = miscOrderLocationDetailList.Where(o => o.MiscOrderDetailId == miscOrderDetail.Id).ToList();
}
}
return miscOrderLocationDetailList;
}
else
{
return null;
}
}
private void CreateMiscOrderDetail(IList<MiscOrderDetail> miscOrderDetailList, string miscOrderNo)
{
int maxSeq = 0;
foreach (MiscOrderDetail miscOrderDetail in miscOrderDetailList)
{
miscOrderDetail.MiscOrderNo = miscOrderNo;
miscOrderDetail.Sequence = ++maxSeq;
if (miscOrderDetail.Uom != miscOrderDetail.BaseUom)
{
miscOrderDetail.UnitQty = this.itemMgr.ConvertItemUomQty(miscOrderDetail.Item, miscOrderDetail.BaseUom, 1, miscOrderDetail.Uom);
}
else
{
miscOrderDetail.UnitQty = 1;
}
this.genericMgr.Create(miscOrderDetail);
}
}
}
}
|
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
namespace WeSplit
{
/// <summary>
/// Interaction logic for SplitMoney.xaml
/// </summary>
public partial class SplitMoney : UserControl
{
public Trips _data;
BindingList<Trips> _list;
string nameTrip;
long Sum = 0;
int CountMember = 0;
public SplitMoney(Trips t)
{
InitializeComponent();
_data = t;
nameTrip = _data.Name;
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
_list = new BindingList<Trips>();
Itemscontrol.ItemsSource = _list;
var appStartPath = AppDomain.CurrentDomain.BaseDirectory;
appStartPath = appStartPath + $"\\ListTrips\\{nameTrip}\\";
var t = new Trips()
{
Expenses = new ObservableCollection<string>(),
Members = new ObservableCollection<string>(),
Money = new ObservableCollection<string>(),
Remark = new ObservableCollection<string>(),
Leader = ""
};
//Members
string fileMembers = appStartPath + $"Members.txt";
var readMembers = File.ReadAllLines(fileMembers);
t.Members.Add(readMembers[0] + " (Leader)");
for (int i = 2; i < readMembers.Length; i = i + 2)
{
t.Members.Add(readMembers[i]);
}
for (int i = 0; i < readMembers.Length; i++)
{
if (i % 2 != 0)
{
t.Money.Add(readMembers[i] + " VNĐ");
CountMember++;
}
}
//Expenses
string fileExpenses = appStartPath + $"Expenses.txt";
var readExpenses = File.ReadAllLines(fileExpenses);
for (int i = 0; i < readExpenses.Length; i = i + 2)
{
string ex = readExpenses[i] + ": " + readExpenses[i + 1] + " VNĐ";
t.Expenses.Add(ex);
}
for (int i = 0; i < readExpenses.Length; i++)
{
if (i % 2 != 0)
Sum += long.Parse(readExpenses[i]) * CountMember;
}
//Remark
Sum = Sum / CountMember;
long al = long.Parse(readMembers[1]);
if (al < Sum)
t.Remark.Add($"Cần phải đóng thêm {Math.Abs(Sum - al)} VNĐ");
else if (al > Sum)
t.Remark.Add($"Tiền dư {al - Sum} VNĐ");
else
t.Remark.Add($"Đã đóng đủ");
for (int i = 3; i < readMembers.Length; i += 2)
{
long a = long.Parse(readMembers[i]);
if (a < Sum)
t.Remark.Add($"Cần phải đóng thêm {Math.Abs(Sum - a)} VNĐ cho {readMembers[0]}");
else if (a > Sum)
t.Remark.Add($"Được {readMembers[0]} trả lại {a - Sum} VNĐ");
else
t.Remark.Add($"Đã đóng đủ");
}
_list.Add(t);
}
private void imgCancel_MouseUp(object sender, MouseButtonEventArgs e)
{
USSplitMoney.Children.Clear();
USSplitMoney.Children.Add(new TripsDetail(_data));
}
}
}
|
public enum EventDefine
{
ShowGamePanel,
DecidePath,
AddScore,
UpdateScoreText,
UpdateDiamondText,
PlayerStartMove,
AddDiamond,
}
|
using Harmony;
using StardewValley;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using System.Threading.Tasks;
namespace BetterMixedSeeds.Patches
{
[HarmonyPatch]
internal class ObjectPatch
{
private static MethodBase TargetMethod()
{
return ModEntry.GetSDVType("Object").GetMethod("cutWeed", BindingFlags.NonPublic | BindingFlags.Instance);
}
/// <summary>
/// Change the condition for the seed index from 473 to 1 (this was preventing Green Beans from being planted as it would decrement the number).
/// </summary>
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
bool changed = false;
ModConfig modConfig = ModEntry.GetConfig();
// Look in config and / 100 (Needs to be reduced from 0 - 100 (Percent) to 0 - 1 (Double))
double mixedSeedDropChance = modConfig.MixedSeedDropChanceFromWeedsWhenNotFiber;
mixedSeedDropChance = Math.Max(0, Math.Min(1, mixedSeedDropChance / 100));
foreach (CodeInstruction instruction in instructions)
{
if (!changed && instruction.opcode == OpCodes.Ldc_R8 && (double)instruction.operand == 0.05)
{
// Changes the mixed seed drop rate when cutting weeds to the config
changed = true;
instruction.operand = mixedSeedDropChance;
}
yield return instruction;
}
}
}
}
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PuddingMovement : PlayerMovement
{
public float slamMultiplier;
public float slamSpeed;
public int charges;
public int sp;
// Start is called before the first frame update
void Start()
{
base.Start();
EventSystem.current.OnPlayerEatFood += addCharge;
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.S) || swipeControls.SwipeDown)
{
StartCoroutine(Slam());
}
}
public IEnumerator Slam()
{
if (sp > 0)
{
no_gravity = true;
control_is_disabled = true;
vel = Vector2.zero;
sp--;
EventSystem.current.PlayerUseAbility();
yield return new WaitForSeconds(0.1f);
base.jumpForce = baseJumpForce * slamMultiplier;
base.jumpVel = baseJumpVel * slamMultiplier;
vel = new Vector2(0, -slamSpeed);
no_gravity = false;
}
}
public void addCharge()
{
if (charges < 3 && sp <= 3)
{
charges++;
if (sp == 3 && charges == 3)
{
charges = 2;
return;
}
if (charges == 3 && sp < 3)
{
charges = 0;
sp++;
EventSystem.current.PlayerGainSkillPoint();
}
}
}
}
|
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace Alabo.Framework.Basic.Relations.Dtos {
/// <summary>
/// 级联数据类型：包含分类与标签
/// </summary>
public class RelationApiOutput {
/// <summary>
/// Id
/// </summary>
public long Id { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 图标
/// </summary>
public string Icon { get; set; }
/// <summary>
/// 关系对应类名
/// </summary>
public string Type { get; set; }
/// <summary>
/// 是否选择, 默认false
/// </summary>
public bool Check { get; set; }
/// <summary>
/// 排序码
/// </summary>
public long SortOrder { get; set; }
/// <summary>
/// 用户Id
/// </summary>
[Display(Name = "用户Id")]
public long UserId { get; set; } = 0;
/// <summary>
/// 是否能添加子级类目
/// </summary>
public bool IsCanAddChild { get; set; } = true;
/// <summary>
/// 父级分类
/// </summary>
public IList<RelationApiOutput> ChildClass { get; set; } = new List<RelationApiOutput>();
}
} |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace TensorFlowLite
{
/// <summary>
/// A simple drawing util
/// </summary>
public class PrimitiveDraw : System.IDisposable
{
private Material material;
private Mesh cube;
public Color color
{
get => material.color;
set => material.color = value;
}
public PrimitiveDraw()
{
material = new Material(Shader.Find("Hidden/Internal-Colored"));
material.hideFlags = HideFlags.HideAndDontSave;
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
material.SetInt("_ZWrite", 0);
//
cube = CreateMesh(PrimitiveType.Cube);
}
public void Dispose()
{
Object.Destroy(material);
material = null;
Object.Destroy(cube);
cube = null;
}
public void Line(Vector3 start, Vector3 end, float thickness)
{
var vec = end - start;
var length = Vector3.Magnitude(vec);
if (length < float.Epsilon)
{
return;
}
var mtx = Matrix4x4.TRS(
(end + start) / 2,
Quaternion.LookRotation(vec, Vector3.up),
new Vector3(thickness, thickness, length));
material.SetPass(0);
Graphics.DrawMeshNow(cube, mtx);
}
public void Cube(Vector3 center, float size)
{
var mtx = Matrix4x4.TRS(
center,
Quaternion.identity,
new Vector3(size, size, size));
material.SetPass(0);
Graphics.DrawMeshNow(cube, mtx);
}
private static Mesh CreateMesh(PrimitiveType type)
{
var go = GameObject.CreatePrimitive(type);
Mesh mesh = go.GetComponent<MeshFilter>().sharedMesh;
Object.Destroy(go);
return mesh;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
namespace ExcelToCSV.Models
{
internal class Sheet
{
public string Name { get; }
public List<Cell> Cells { get; }
public List<List<Cell>> Rows
{
get
{
List<List<Cell>> rows = new List<List<Cell>>();
foreach (var row in Cells.GroupBy(q => q.RowIndex).OrderBy(q => q.Key))
{
List<Cell> list = new List<Cell>();
foreach (var cell in row.OrderBy(q => q.ColumnIndex))
{
list.Add(cell);
}
rows.Add(list);
}
return rows;
}
}
public Sheet(DataTable table)
{
Name = table.TableName;
Cells = GetCells(table);
}
List<Cell> GetCells(DataTable table)
{
List<Cell> cells = new List<Cell>();
for (int i = 0; i < table.Rows.Count; i++)
{
for (int j = 0; j < table.Columns.Count; j++)
{
Cell cell = new Cell(i, j, table.Rows[i][j]);
cells.Add(cell);
}
}
return cells;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using com.Sconit.Entity.BIL;
using com.Sconit.Entity.Exception;
using com.Sconit.Entity.MD;
using NHibernate.Criterion;
using Castle.Services.Transaction;
using com.Sconit.Entity.CUST;
using NHibernate.Type;
using NHibernate;
using com.Sconit.Utility;
using System.IO;
using NPOI.HSSF.UserModel;
using System.Collections;
using NPOI.SS.UserModel;
namespace com.Sconit.Service.Impl
{
[Transactional]
public class ItemMgrImpl : BaseMgr, IItemMgr
{
#region 变量
public IQueryMgr queryMgr { get; set; }
public IGenericMgr genericMgr { get; set; }
#endregion
private static IList<UomConversion> cachedAllUomConversion;
private static Dictionary<string, Item> cachedAllItem;
private static DateTime cacheDateTime;
#region public methods
private static object cacheUomLock = new object();
public IList<UomConversion> GetCacheAllUomConversionList()
{
lock (cacheUomLock)
{
if (cachedAllUomConversion == null || cacheDateTime < DateTime.Now.AddMinutes(-10))
{
cacheDateTime = DateTime.Now;
cachedAllUomConversion = this.genericMgr.FindAll<UomConversion>();
}
return cachedAllUomConversion;
}
}
private UomConversion LoadUomConversion(string itemCode, string sourceUomCode, string targetUomCode)
{
return GetCacheAllUomConversionList()
.FirstOrDefault(p => p.Item.Code == itemCode && p.BaseUom == sourceUomCode && p.AlterUom == targetUomCode);
}
private static object cacheLock = new object();
public Dictionary<string, Item> GetCacheAllItem()
{
lock (cacheLock)
{
if (cachedAllItem == null || cacheDateTime < DateTime.Now.AddMinutes(-10))
{
cacheDateTime = DateTime.Now;
var allItem = this.genericMgr.FindAll<Item>();
cachedAllItem = allItem.ToDictionary(d => d.Code, d => d);
}
return cachedAllItem;
}
}
public Item GetCacheItem(string itemCode)
{
return GetCacheAllItem().ValueOrDefault(itemCode);
}
public void ResetItemCache()
{
cacheDateTime = DateTime.MinValue;
}
public IList<ItemKit> GetKitItemChildren(string kitCode)
{
return GetKitItemChildren(kitCode, false);
}
public IList<ItemKit> GetKitItemChildren(string kitItem, bool includeInActive)
{
DetachedCriteria criteria = DetachedCriteria.For<ItemKit>();
criteria.Add(Expression.Eq("KitItem", kitItem));
criteria.Add(Expression.Eq("IsActive", includeInActive));
return queryMgr.FindAll<ItemKit>(criteria);
}
public decimal ConvertItemUomQty(string itemCode, string sourceUomCode, decimal sourceQty, string targetUomCode)
{
if (itemCode == null || sourceUomCode == null || targetUomCode == null)
{
throw new BusinessException("UomConversion Error:itemCode Or sourceUomCode Or targetUomCode is null");
}
if (sourceUomCode == targetUomCode || sourceQty == 0)
{
return sourceQty;
}
IList<UomConversion> allUomConversionList = GetCacheAllUomConversionList()
.Where(p => p.Item == null || string.Equals(p.Item.Code, itemCode)).ToList();
if (allUomConversionList != null)
{
List<UomConversion> uomConversionList = allUomConversionList.Where(u => u.Item != null).ToList();
foreach (UomConversion y in allUomConversionList)
{
if (uomConversionList.Where(x =>
(string.Equals(x.AlterUom, y.AlterUom) && string.Equals(x.BaseUom, y.BaseUom))
|| (string.Equals(x.AlterUom, y.BaseUom) && string.Equals(x.BaseUom, y.AlterUom)))
.Count() == 0)
{
uomConversionList.Add(y);
}
}
foreach (UomConversion u in uomConversionList)
{
//顺
if (string.Equals(u.BaseUom, sourceUomCode))
{
u.Qty = sourceQty * u.AlterQty / u.BaseQty;
u.IsAsc = true;
if (string.Equals(u.AlterUom, targetUomCode))
{
return u.Qty.Value;
}
}
//反
else if (string.Equals(u.AlterUom, sourceUomCode))
{
u.Qty = sourceQty * u.BaseQty / u.AlterQty;
u.IsAsc = false;
if (string.Equals(u.BaseUom, targetUomCode))
{
return u.Qty.Value;
}
}
}
for (int i = 1; i < uomConversionList.Count; i++)
{
foreach (UomConversion uomConversion1 in uomConversionList)
{
if (uomConversion1.Qty.HasValue)
{
foreach (UomConversion uomConversion2 in uomConversionList)
{
//顺
if (uomConversion1.IsAsc)
{
//顺
if (string.Equals(uomConversion2.BaseUom, uomConversion1.AlterUom) && !uomConversion2.Qty.HasValue)
{
uomConversion2.Qty = uomConversion1.Qty.Value * uomConversion2.AlterQty / uomConversion2.BaseQty;
uomConversion2.IsAsc = true;
if (string.Equals(uomConversion2.AlterUom, targetUomCode))
{
return uomConversion2.Qty.Value;
}
}
//反
else if (string.Equals(uomConversion2.AlterUom, uomConversion1.AlterUom) && !uomConversion2.Qty.HasValue)
{
uomConversion2.Qty = uomConversion1.Qty.Value * uomConversion2.BaseQty / uomConversion2.AlterQty;
uomConversion2.IsAsc = false;
if (string.Equals(uomConversion2.BaseUom, targetUomCode))
{
return uomConversion2.Qty.Value;
}
}
}
//反
else
{
//顺
if (string.Equals(uomConversion2.BaseUom, uomConversion1.BaseUom) && !uomConversion2.Qty.HasValue)
{
uomConversion2.Qty = uomConversion1.Qty.Value * uomConversion2.AlterQty / uomConversion2.BaseQty;
uomConversion2.IsAsc = true;
if (string.Equals(uomConversion2.AlterUom, targetUomCode))
{
return uomConversion2.Qty.Value;
}
}
//反
else if (string.Equals(uomConversion2.AlterUom, uomConversion1.BaseUom) && !uomConversion2.Qty.HasValue)
{
uomConversion2.Qty = uomConversion1.Qty.Value * uomConversion2.BaseQty / uomConversion2.AlterQty;
uomConversion2.IsAsc = false;
if (string.Equals(uomConversion2.BaseUom, targetUomCode))
{
return uomConversion2.Qty.Value;
}
}
}
}
}
}
}
}
throw new BusinessException(string.Format("单位转换没有找到:物料{0},原单位{1},转换后单位{2}", itemCode, sourceUomCode, targetUomCode));
}
/*
public decimal ConvertItemUomQty(string itemCode, string sourceUomCode, decimal sourceQty, string targetUomCode)
{
if (sourceUomCode == targetUomCode || sourceQty == 0)
{
return sourceQty;
}
#region 第一次转换单位，使用Item定义的单位转换
DetachedCriteria criteria = DetachedCriteria.For<UomConversion>();
criteria.Add(Expression.Eq("Item.Code", itemCode));
IList<UomConversion> SpecifiedItemUomConversionList = queryMgr.FindAll<UomConversion>(criteria);
UomConversion uomConversion = (from conv in SpecifiedItemUomConversionList
where (conv.BaseUom == sourceUomCode && conv.AlterUom == targetUomCode)
|| (conv.BaseUom == targetUomCode && conv.AlterUom == sourceUomCode)
select conv).FirstOrDefault();
if (uomConversion != null)
{
if (uomConversion.BaseUom == sourceUomCode)
{
return (sourceQty * uomConversion.AlterQty / uomConversion.BaseQty);
}
else
{
return (sourceQty * uomConversion.BaseQty / uomConversion.AlterQty);
}
}
#endregion
#region 第二次转换单位，使用通用的单位转换
criteria = DetachedCriteria.For<UomConversion>();
criteria.Add(Expression.IsNull("Item"));
IList<UomConversion> genericItemUomConversionList = queryMgr.FindAll<UomConversion>(criteria);
uomConversion = (from conv in genericItemUomConversionList
where (conv.BaseUom == sourceUomCode && conv.AlterUom == targetUomCode)
|| (conv.BaseUom == targetUomCode && conv.AlterUom == sourceUomCode)
select conv).FirstOrDefault();
if (uomConversion != null)
{
if (uomConversion.BaseUom == sourceUomCode)
{
return (sourceQty * uomConversion.AlterQty / uomConversion.BaseQty);
}
else
{
return (sourceQty * uomConversion.BaseQty / uomConversion.AlterQty);
}
}
#endregion
#region 无级单位转换
List<UomConversion> mergedItemUomConversionList = new List<UomConversion>();
mergedItemUomConversionList.AddRange(SpecifiedItemUomConversionList);
mergedItemUomConversionList.AddRange(genericItemUomConversionList);
//思路：用sourceUomCode、targetUomCode分别和uomConversion.BaseUom、uomConversion.AlterUom匹配
//总共4种情况，循环嵌套往下查找。
//每次嵌套需要过滤掉已经用过得uomConversion来防止死循环。
decimal? targetQty = NestConvertItemUomQty(mergedItemUomConversionList, sourceUomCode, targetUomCode, sourceQty, false);
if (!targetQty.HasValue)
{
targetQty = NestConvertItemUomQty(mergedItemUomConversionList, targetUomCode, sourceUomCode, sourceQty, true);
}
if (targetQty.HasValue)
{
return targetQty.Value;
}
else
{
throw new BusinessException("Errors.Item.UomConvertionNotFound", itemCode, sourceUomCode, targetUomCode);
}
#endregion
}
*/
public PriceListDetail GetItemPrice(string itemCode, string uom, string priceList, string currency, DateTime? effectiveDate)
{
if (!effectiveDate.HasValue)
{
effectiveDate = DateTime.Now;
}
DetachedCriteria criteria = DetachedCriteria.For<PriceListDetail>();
criteria.CreateAlias("PriceList", "pl");
criteria.Add(Expression.Eq("pl.Code", priceList));
criteria.Add(Expression.Eq("Item", itemCode));
criteria.Add(Expression.Eq("Uom", uom));
criteria.Add(Expression.Eq("pl.Currency", currency));
criteria.Add(Expression.Le("StartDate", effectiveDate));
criteria.Add(Expression.Or(Expression.Ge("EndDate", effectiveDate), Expression.IsNull("EndDate")));
criteria.AddOrder(Order.Desc("StartDate"));
IList<PriceListDetail> resultList = queryMgr.FindAll<PriceListDetail>(criteria, 0, 1);
if (resultList != null && resultList.Count() > 0)
{
return resultList[0];
}
else
{
return null;
}
}
[Transaction(TransactionMode.Requires)]
public void CreateItem(Item item)
{
ItemPackage itemPackage = new ItemPackage();
itemPackage.Item = item.Code;
itemPackage.IsDefault = true;
itemPackage.UnitCount = item.UnitCount;
itemPackage.Description = string.Empty;
genericMgr.Create(item);
genericMgr.Create(itemPackage);
this.ResetItemCache();
GetCacheAllItem();
//if (!cachedAllItem.ContainsKey(item.Code))
//{
// cachedAllItem.Add(item.Code, item);
//}
}
[Transaction(TransactionMode.Requires)]
public void UpdateItem(Item item)
{
string hql = "from ItemPackage where Item = ? and UnitCount = ?";
IList<ItemPackage> itemPackageList = queryMgr.FindAll<ItemPackage>(hql, new object[] { item.Code, item.UnitCount });
if (itemPackageList != null && itemPackageList.Count > 0)
{
ItemPackage itemPackage = itemPackageList[0];
if (!itemPackage.IsDefault)
{
itemPackage.IsDefault = true;
genericMgr.Update(itemPackage);
}
}
else
{
#region 原默认包装至False
hql = "from ItemPackage as i where i.Item = ? and i.IsDefault= ?";
IList<ItemPackage> defualtItemPackageList = queryMgr.FindAll<ItemPackage>(hql, new object[] { item.Code, true });
for (int i = 0; i < defualtItemPackageList.Count; i++)
{
defualtItemPackageList[i].IsDefault = false;
this.genericMgr.Update(defualtItemPackageList[i]);
}
#endregion
#region 没有找到包装，新增包装
ItemPackage itemPackage = new ItemPackage();
itemPackage.Item = item.Code;
itemPackage.IsDefault = true;
itemPackage.UnitCount = item.UnitCount;
itemPackage.Description = string.Empty;
this.genericMgr.Create(itemPackage);
#endregion
}
//GetCacheAllItem();
//if (cachedAllItem.ContainsKey(item.Code))
//{
// cachedAllItem[item.Code] = item;
//}
genericMgr.Update(item);
this.ResetItemCache();
}
public IList<ItemDiscontinue> GetItemDiscontinues(string itemCode, DateTime effectiveDate)
{
string hql = "from ItemDiscontinue where Item = ? and StartDate < ? and (EndDate is null or EndDate >= ?) order by Priority ";
return this.genericMgr.FindAll<ItemDiscontinue>(hql, new object[] { itemCode, effectiveDate, effectiveDate });
}
public IList<ItemDiscontinue> GetParentItemDiscontinues(string itemCode, DateTime effectiveDate)
{
string hql = "from ItemDiscontinue where DiscontinueItem = ? and StartDate < ? and (EndDate is null or EndDate >= ?)";
return this.genericMgr.FindAll<ItemDiscontinue>(hql, new object[] { itemCode, effectiveDate, effectiveDate });
}
public IList<Item> GetItems(IList<string> itemCodeList)
{
if (itemCodeList != null && itemCodeList.Count > 0)
{
//IList<Item> itemList = this.genericMgr.FindAllIn<Item>("from Item where code in(?", itemCodeList);
IList<Item> itemList = new List<Item>();
var allItems = GetCacheAllItem();
foreach (var itemCode in itemCodeList)
{
itemList.Add(allItems[itemCode]);
}
return itemList;
}
return null;
}
#region 保管员
[Transaction(TransactionMode.Requires)]
public void CreateCustodian(Custodian custodian)
{
string ItemCodeStr = custodian.ItemCodes.Replace("\r\n", ",");
string[] ItemCodeArray = ItemCodeStr.Split(',');
BusinessException businessException = new BusinessException();
#region 判定Item是否有效
foreach (string itemCode in ItemCodeArray.Distinct())
{
if (itemCode != null && itemCode != "")
{
IList<Item> items = this.genericMgr.FindAll<Item>("from Item where Code='" + itemCode + "'");
if (items == null || items.Count == 0)
{
businessException.AddMessage(itemCode.ToString() + ",");
}
}
}
if (businessException.HasMessage)
{
businessException.AddMessage("不存在。");
throw businessException;
}
#endregion
#region 判定物料是否已经分配保管员
string hql = string.Empty;
IList<object> parm = new List<object>();
foreach (string itemCode in ItemCodeArray.Distinct())
{
if (hql == string.Empty)
{
hql = "from Custodian where Location=? and UserCode=? and item in (?";
parm.Add(custodian.Location);
parm.Add(custodian.UserCode);
}
else
{
hql += ", ?";
}
parm.Add(itemCode);
}
hql += ")";
IList<Custodian> CustodianList = this.queryMgr.FindAll<Custodian>(hql, parm.ToArray());
if (CustodianList != null && CustodianList.Count > 0)
{
foreach (Custodian cd in CustodianList)
{
businessException.AddMessage(cd.Item.ToString() + ",");
}
if (businessException.HasMessage)
{
businessException.AddMessage("已经分配保管员。");
throw businessException;
}
}
#endregion
foreach (string itemCode in ItemCodeArray.Distinct())
{
if (itemCode != "")
{
Custodian cus = new Custodian();
cus.Item = itemCode;
cus.Location = custodian.Location;
cus.UserCode = custodian.UserCode;
this.genericMgr.Create(cus);
}
}
}
#endregion
public void DeleteItem(string itemCode)
{
this.genericMgr.Delete("from ItemPackage where Item = ? ", new object[] { itemCode }, new IType[] { NHibernateUtil.String });
this.genericMgr.DeleteById<Item>(itemCode);
//GetCacheAllItem();
//if (cachedAllItem.ContainsKey(itemCode))
//{
// cachedAllItem.Remove(itemCode);
//}
this.ResetItemCache();
}
public IList<Uom> GetItemUoms(string itemCode)
{
IList<Uom> uomList = new List<Uom>();
itemCode = itemCode == null ? string.Empty : itemCode;
var _items = this.genericMgr.FindAll<Item>("from Item where Code = ? ", itemCode);
if (_items != null && _items.Count() == 1)
{
var _item = _items[0];
List<string> uomCodes = new List<string>();
GetUomCodes(_item.Uom, uomCodes);
//IList<UomConversion> uomConvList = genericMgr.FindAll<UomConversion>
// ("from UomConversion as u where u.Item.Code = ? and (u.AlterUom = ? or u.BaseUom = ?)",
// new object[] { itemCode, _item.Uom, _item.Uom });
var uomConvList = GetCacheAllUomConversionList().Where(u => u.Item != null && u.Item.Code == itemCode
&& (u.AlterUom == _item.Uom || u.BaseUom == _item.Uom));
if (uomConvList != null && uomConvList.Count() > 0)
{
foreach (var uomConv in uomConvList)
{
if (uomConv.BaseUom == _item.Uom && !uomCodes.Contains(uomConv.AlterUom))
{
GetUomCodes(uomConv.AlterUom, uomCodes);
}
else if (uomConv.AlterUom == _item.Uom && !uomCodes.Contains(uomConv.BaseUom))
{
GetUomCodes(uomConv.BaseUom, uomCodes);
}
}
}
foreach (var uomCode in uomCodes.Distinct())
{
uomList.Add(queryMgr.FindById<Uom>(uomCode));
}
}
return uomList;
}
public Dictionary<string, Item> GetRefItemCode(string flowCode, List<string> refItemCodeList)
{
Dictionary<string, Item> itemDic = new Dictionary<string, Item>();
if (!string.IsNullOrWhiteSpace(flowCode))
{
string sql = @"select f.Item, case when ltrim(isnull(f.RefItemCode,''))='' then i.RefCode else f.RefItemCode end as RefCode into #item
from SCM_FlowDet f join MD_Item i on f.Item = i.Code where f.Flow = '9306-500026'
select * from #item where RefCode in(?";
var itemCodes = this.genericMgr.FindAllWithNativeSqlIn<object[]>(sql, refItemCodeList)
.GroupBy(p => p[0], (k, g) => new { Item = (string)k, RefCode = (string)(g.First()[1]) });
foreach (var itemCode in itemCodes)
{
itemDic.Add(itemCode.RefCode, GetCacheItem(itemCode.Item));
}
}
else
{
itemDic = refItemCodeList.GroupJoin(GetCacheAllItem().Select(p => p.Value), r => r, i => i.ReferenceCode, (r, i) => new { r, i })
.Where(p => p.i != null && p.i.Count() > 0).ToDictionary(d => d.r, d => d.i.First());
}
return itemDic;
}
#endregion
#region private methods
private decimal? NestConvertItemUomQty(IList<UomConversion> itemUomConversionList, string sourceUomCode, string targetUomCode, decimal convQty, bool isUomReversed)
{
IList<UomConversion> matchedUomConversionList = (from conv in itemUomConversionList
where (conv.BaseUom == sourceUomCode) //用Source Uom匹配
|| (conv.AlterUom == sourceUomCode)
orderby conv.Item descending //把Item有值的放前面
select conv).ToList();
foreach (UomConversion matchedUomConversion in matchedUomConversionList)
{
if (matchedUomConversion.BaseUom == sourceUomCode)
{
sourceUomCode = matchedUomConversion.AlterUom;
if (isUomReversed)
{
convQty = (convQty * matchedUomConversion.AlterQty / matchedUomConversion.BaseQty);
}
else
{
convQty = (convQty * matchedUomConversion.BaseQty / matchedUomConversion.AlterQty);
}
}
else
{
sourceUomCode = matchedUomConversion.BaseUom;
if (isUomReversed)
{
convQty = (convQty * matchedUomConversion.BaseQty / matchedUomConversion.AlterQty);
}
else
{
convQty = (convQty * matchedUomConversion.AlterQty / matchedUomConversion.BaseQty);
}
}
if (sourceUomCode == targetUomCode)
{
//新的Source Uom等于Target Uom, 找到目标转换单位
return convQty;
}
else
{
//没有找到目标转换单位
//先过滤掉已经匹配过的转换
IList<UomConversion> filteredUomConversionList = itemUomConversionList.Where(m => !m.Equals(matchedUomConversion)).ToList();
//再嵌套往下查找
decimal? targetQty = NestConvertItemUomQty(filteredUomConversionList, sourceUomCode, targetUomCode, convQty, false);
if (targetQty.HasValue)
{
return targetQty;
}
else
{
targetQty = NestConvertItemUomQty(filteredUomConversionList, targetUomCode, sourceUomCode, convQty, true);
}
}
}
return null;
}
private void GetUomCodes(string uom, List<string> uomCodes)
{
uomCodes.Add(uom);
//IList<UomConversion> uomConvList = queryMgr.FindAll<UomConversion>
// ("from UomConversion as u where (u.BaseUom=? or u.AlterUom=? ) ",
// new object[] { uom, uom });
var uomConvList = GetCacheAllUomConversionList().Where(
u => u.Item == null && (u.BaseUom == uom || u.AlterUom == uom));
if (uomConvList != null && uomConvList.Count() > 0)
{
foreach (var uomConv in uomConvList)
{
if (uomConv.BaseUom == uom && !uomCodes.Contains(uomConv.AlterUom))
{
uomCodes.Add(uomConv.AlterUom);
GetUomCodes(uomConv.AlterUom, uomCodes);
}
else if (uomConv.AlterUom == uom && !uomCodes.Contains(uomConv.BaseUom))
{
uomCodes.Add(uomConv.BaseUom);
GetUomCodes(uomConv.BaseUom, uomCodes);
}
}
}
}
#endregion
[Transaction(TransactionMode.Requires)]
public void ImportItem(Stream inputStream)
{
if (inputStream.Length == 0)
{
throw new BusinessException("Import.Stream.Empty");
}
HSSFWorkbook workbook = new HSSFWorkbook(inputStream);
ISheet sheet = workbook.GetSheetAt(0);
IEnumerator rows = sheet.GetRowEnumerator();
ImportHelper.JumpRows(rows, 1);
#region 列定义
//物料 物料描述 旧物料号 物料类型 基本计量单位 物料组 虚拟物料
int colItem = 0;//物料
int colItemDesc = 1;//物料描述
int colItemRef = 2;//旧物料号
int colItemCategory = 3;//物料类型
int colUom = 4;//基本计量单位
int colUc = 5;//基本计量单位
int colItemGroup = 6;//物料组
int colIsVirtual = 7;//虚拟物料
int colDivision = 8;//产品组
#endregion
var errorMessage = new BusinessException();
int colCount = 0;
List<Item> rowDataList = new List<Item>();
#region 读取数据
while (rows.MoveNext())
{
HSSFRow row = (HSSFRow)rows.Current;
if (!ImportHelper.CheckValidDataRow(row, 0, 7))
{
break;//边界
}
colCount++;
bool hasError = false;
var rowData = new Item();
#region
rowData.Code = ImportHelper.GetCellStringValue(row.GetCell(colItem));
if (rowData.Code == null)
{
errorMessage.AddMessage("第{0}行物料代码不能为空", colCount.ToString());
hasError = true;
}
rowData.Description = ImportHelper.GetCellStringValue(row.GetCell(colItemDesc));
if (rowData.Description == null)
{
errorMessage.AddMessage("第{0}行物料描述不能为空", colCount.ToString());
hasError = true;
}
rowData.ReferenceCode = ImportHelper.GetCellStringValue(row.GetCell(colItemRef));
rowData.ItemCategory = ImportHelper.GetCellStringValue(row.GetCell(colItemCategory));
if (rowData.ItemCategory == null)
{
errorMessage.AddMessage("第{0}行物料类型不能为空", colCount.ToString());
hasError = true;
}
rowData.Uom = ImportHelper.GetCellStringValue(row.GetCell(colUom));
if (rowData.Uom == null)
{
errorMessage.AddMessage("第{0}行基本计量单位不能为空", colCount.ToString());
hasError = true;
}
else
{
rowData.Uom = rowData.Uom.ToUpper();
}
string uc = ImportHelper.GetCellStringValue(row.GetCell(colUc));
decimal _uc = 1;
decimal.TryParse(uc, out _uc);
rowData.UnitCount = _uc;
rowData.MaterialsGroup = ImportHelper.GetCellStringValue(row.GetCell(colItemGroup));
if (rowData.MaterialsGroup == null)
{
errorMessage.AddMessage("第{0}行物料组不能为空", colCount.ToString());
hasError = true;
}
else
{
rowData.MaterialsGroup = rowData.MaterialsGroup.ToUpper();
}
if (ImportHelper.GetCellStringValue(row.GetCell(colIsVirtual)) == "X")
{
rowData.IsVirtual = true;
}
rowData.Division = ImportHelper.GetCellStringValue(row.GetCell(colDivision));
#endregion
if (!hasError)
{
rowData.IsActive = true;
rowData.UnitCount = 1;
rowDataList.Add(rowData);
}
}
#endregion
if (rowDataList.Count == 0)
{
errorMessage.AddMessage("没有找到有效的数据.");
throw errorMessage;
}
#region 验证重复明细
var dataRowGroup = rowDataList.GroupBy(p => p.Code).Where(p => p.Count() > 1).Select(p => new { p.Key, p.First().Description });
foreach (var dataRow in dataRowGroup)
{
errorMessage.AddMessage("存在重复的明细:物料{0}[{1}]", dataRow.Key, dataRow.Description);
}
#endregion
if (!errorMessage.HasMessage)
{
var allItems = GetCacheAllItem();
foreach (var rowData in rowDataList)
{
if (allItems.ContainsKey(rowData.Code))
{
var item = allItems[rowData.Code];
if (item.Description != rowData.Description ||
item.ReferenceCode != rowData.ReferenceCode ||
item.MaterialsGroup != rowData.MaterialsGroup ||
item.ItemCategory != rowData.ItemCategory ||
item.UnitCount != rowData.UnitCount)
{
item.Description = rowData.Description;
item.ReferenceCode = rowData.ReferenceCode;
item.MaterialsGroup = rowData.MaterialsGroup;
item.ItemCategory = rowData.ItemCategory;
item.UnitCount = rowData.UnitCount;
this.genericMgr.Update(item);
}
}
else
{
this.genericMgr.Create(rowData);
}
}
}
else
{
throw errorMessage;
}
}
}
}
|
namespace AgendaTelefonica.Console.Entities;
public abstract class Notification
{
protected readonly List<string> _notifications = new();
public IEnumerable<string> Notifications => _notifications;
public bool HaveNotifications => _notifications.Count > 0;
} |
using System;
using System.Collections.Generic;
using System.Data;
using Terminal.Gui;
using System.Linq;
using System.Globalization;
using static Terminal.Gui.TableView;
namespace UICatalog.Scenarios {
[ScenarioMetadata (Name: "TableEditor", Description: "Implements data table editor using the TableView control.")]
[ScenarioCategory ("TableView")]
[ScenarioCategory ("Controls")]
[ScenarioCategory ("Dialogs")]
[ScenarioCategory ("Text and Formatting")]
[ScenarioCategory ("Top Level Windows")]
public class TableEditor : Scenario
{
TableView tableView;
private MenuItem miAlwaysShowHeaders;
private MenuItem miHeaderOverline;
private MenuItem miHeaderMidline;
private MenuItem miHeaderUnderline;
private MenuItem miShowHorizontalScrollIndicators;
private MenuItem miCellLines;
private MenuItem miFullRowSelect;
private MenuItem miExpandLastColumn;
private MenuItem miSmoothScrolling;
private MenuItem miAlternatingColors;
private MenuItem miCursor;
ColorScheme redColorScheme;
ColorScheme redColorSchemeAlt;
ColorScheme alternatingColorScheme;
public override void Setup ()
{
Win.Title = this.GetName();
Win.Y = 1; // menu
Win.Height = Dim.Fill (1); // status bar
Application.Top.LayoutSubviews ();
this.tableView = new TableView () {
X = 0,
Y = 0,
Width = Dim.Fill (),
Height = Dim.Fill (1),
};
var menu = new MenuBar (new MenuBarItem [] {
new MenuBarItem ("_File", new MenuItem [] {
new MenuItem ("_OpenBigExample", "", () => OpenExample(true)),
new MenuItem ("_OpenSmallExample", "", () => OpenExample(false)),
new MenuItem ("OpenCharacter_Map","",()=>OpenUnicodeMap()),
new MenuItem ("_CloseExample", "", () => CloseExample()),
new MenuItem ("_Quit", "", () => Quit()),
}),
new MenuBarItem ("_View", new MenuItem [] {
miAlwaysShowHeaders = new MenuItem ("_AlwaysShowHeaders", "", () => ToggleAlwaysShowHeader()){Checked = tableView.Style.AlwaysShowHeaders, CheckType = MenuItemCheckStyle.Checked },
miHeaderOverline = new MenuItem ("_HeaderOverLine", "", () => ToggleOverline()){Checked = tableView.Style.ShowHorizontalHeaderOverline, CheckType = MenuItemCheckStyle.Checked },
miHeaderMidline = new MenuItem ("_HeaderMidLine", "", () => ToggleHeaderMidline()){Checked = tableView.Style.ShowVerticalHeaderLines, CheckType = MenuItemCheckStyle.Checked },
miHeaderUnderline = new MenuItem ("_HeaderUnderLine", "", () => ToggleUnderline()){Checked = tableView.Style.ShowHorizontalHeaderUnderline, CheckType = MenuItemCheckStyle.Checked },
miShowHorizontalScrollIndicators = new MenuItem ("_HorizontalScrollIndicators", "", () => ToggleHorizontalScrollIndicators()){Checked = tableView.Style.ShowHorizontalScrollIndicators, CheckType = MenuItemCheckStyle.Checked },
miFullRowSelect =new MenuItem ("_FullRowSelect", "", () => ToggleFullRowSelect()){Checked = tableView.FullRowSelect, CheckType = MenuItemCheckStyle.Checked },
miCellLines =new MenuItem ("_CellLines", "", () => ToggleCellLines()){Checked = tableView.Style.ShowVerticalCellLines, CheckType = MenuItemCheckStyle.Checked },
miExpandLastColumn = new MenuItem ("_ExpandLastColumn", "", () => ToggleExpandLastColumn()){Checked = tableView.Style.ExpandLastColumn, CheckType = MenuItemCheckStyle.Checked },
miSmoothScrolling = new MenuItem ("_SmoothHorizontalScrolling", "", () => ToggleSmoothScrolling()){Checked = tableView.Style.SmoothHorizontalScrolling, CheckType = MenuItemCheckStyle.Checked },
new MenuItem ("_AllLines", "", () => ToggleAllCellLines()),
new MenuItem ("_NoLines", "", () => ToggleNoCellLines()),
miAlternatingColors = new MenuItem ("Alternating Colors", "", () => ToggleAlternatingColors()){CheckType = MenuItemCheckStyle.Checked},
miCursor = new MenuItem ("Invert Selected Cell First Character", "", () => ToggleInvertSelectedCellFirstCharacter()){Checked = tableView.Style.InvertSelectedCellFirstCharacter,CheckType = MenuItemCheckStyle.Checked},
new MenuItem ("_ClearColumnStyles", "", () => ClearColumnStyles()),
new MenuItem ("Sho_w All Columns", "", ()=>ShowAllColumns())
}),
new MenuBarItem ("_Column", new MenuItem [] {
new MenuItem ("_Set Max Width", "", SetMaxWidth),
new MenuItem ("_Set Min Width", "", SetMinWidth),
new MenuItem ("_Set MinAcceptableWidth", "",SetMinAcceptableWidth),
new MenuItem ("_Set All MinAcceptableWidth=1", "",SetMinAcceptableWidthToOne),
}),
});
Application.Top.Add (menu);
var statusBar = new StatusBar (new StatusItem [] {
new StatusItem(Key.F2, "~F2~ OpenExample", () => OpenExample(true)),
new StatusItem(Key.F3, "~F3~ CloseExample", () => CloseExample()),
new StatusItem(Key.F4, "~F4~ OpenSimple", () => OpenSimple(true)),
new StatusItem(Key.CtrlMask | Key.Q, "~^Q~ Quit", () => Quit()),
});
Application.Top.Add (statusBar);
Win.Add (tableView);
var selectedCellLabel = new Label(){
X = 0,
Y = Pos.Bottom(tableView),
Text = "0,0",
Width = Dim.Fill(),
TextAlignment = TextAlignment.Right
};
Win.Add(selectedCellLabel);
tableView.SelectedCellChanged += (e) => { selectedCellLabel.Text = $"{tableView.SelectedRow},{tableView.SelectedColumn}"; };
tableView.CellActivated += EditCurrentCell;
tableView.KeyPress += TableViewKeyPress;
SetupScrollBar();
redColorScheme = new ColorScheme(){
Disabled = Win.ColorScheme.Disabled,
HotFocus = Win.ColorScheme.HotFocus,
Focus = Win.ColorScheme.Focus,
Normal = Application.Driver.MakeAttribute(Color.Red,Win.ColorScheme.Normal.Background)
};
alternatingColorScheme = new ColorScheme(){
Disabled = Win.ColorScheme.Disabled,
HotFocus = Win.ColorScheme.HotFocus,
Focus = Win.ColorScheme.Focus,
Normal = Application.Driver.MakeAttribute(Color.White,Color.BrightBlue)
};
redColorSchemeAlt = new ColorScheme(){
Disabled = Win.ColorScheme.Disabled,
HotFocus = Win.ColorScheme.HotFocus,
Focus = Win.ColorScheme.Focus,
Normal = Application.Driver.MakeAttribute(Color.Red,Color.BrightBlue)
};
// if user clicks the mouse in TableView
tableView.MouseClick += e => {
tableView.ScreenToCell (e.MouseEvent.X, e.MouseEvent.Y, out DataColumn clickedCol);
if (clickedCol != null) {
if (e.MouseEvent.Flags.HasFlag (MouseFlags.Button1Clicked)) {
// left click in a header
SortColumn (clickedCol);
} else if (e.MouseEvent.Flags.HasFlag (MouseFlags.Button3Clicked)) {
// right click in a header
ShowHeaderContextMenu (clickedCol, e);
}
}
};
}
private void ShowAllColumns ()
{
foreach(var colStyle in tableView.Style.ColumnStyles) {
colStyle.Value.Visible = true;
}
tableView.Update ();
}
private void SortColumn (DataColumn clickedCol)
{
var sort = GetProposedNewSortOrder (clickedCol, out var isAsc);
SortColumn (clickedCol, sort, isAsc);
}
private void SortColumn (DataColumn clickedCol, string sort, bool isAsc)
{
// set a sort order
tableView.Table.DefaultView.Sort = sort;
// copy the rows from the view
var sortedCopy = tableView.Table.DefaultView.ToTable ();
tableView.Table.Rows.Clear ();
foreach (DataRow r in sortedCopy.Rows) {
tableView.Table.ImportRow (r);
}
foreach (DataColumn col in tableView.Table.Columns) {
// remove any lingering sort indicator
col.ColumnName = TrimArrows(col.ColumnName);
// add a new one if this the one that is being sorted
if (col == clickedCol) {
col.ColumnName += isAsc ? '▲' : '▼';
}
}
tableView.Update ();
}
private string TrimArrows (string columnName)
{
return columnName.TrimEnd ('▼', '▲');
}
private string StripArrows (string columnName)
{
return columnName.Replace ("▼", "").Replace ("▲", "");
}
private string GetProposedNewSortOrder (DataColumn clickedCol, out bool isAsc)
{
// work out new sort order
var sort = tableView.Table.DefaultView.Sort;
if (sort?.EndsWith ("ASC") ?? false) {
sort = $"{clickedCol.ColumnName} DESC";
isAsc = false;
} else {
sort = $"{clickedCol.ColumnName} ASC";
isAsc = true;
}
return sort;
}
private void ShowHeaderContextMenu (DataColumn clickedCol, View.MouseEventArgs e)
{
var sort = GetProposedNewSortOrder (clickedCol, out var isAsc);
var contextMenu = new ContextMenu (e.MouseEvent.X + 1, e.MouseEvent.Y + 1,
new MenuBarItem (new MenuItem [] {
new MenuItem ($"Hide {TrimArrows(clickedCol.ColumnName)}", "", () => HideColumn(clickedCol)),
new MenuItem ($"Sort {StripArrows(sort)}","",()=>SortColumn(clickedCol,sort,isAsc)),
})
);
contextMenu.Show ();
}
private void HideColumn (DataColumn clickedCol)
{
var style = tableView.Style.GetOrCreateColumnStyle (clickedCol);
style.Visible = false;
tableView.Update ();
}
private DataColumn GetColumn ()
{
if (tableView.Table == null)
return null;
if (tableView.SelectedColumn < 0 || tableView.SelectedColumn > tableView.Table.Columns.Count)
return null;
return tableView.Table.Columns [tableView.SelectedColumn];
}
private void SetMinAcceptableWidthToOne ()
{
var columns = tableView?.Table?.Columns;
if (columns is null) {
MessageBox.ErrorQuery ("No Table", "No table is currently loaded", "Ok");
return;
}
foreach (DataColumn c in tableView.Table.Columns)
{
var style = tableView.Style.GetOrCreateColumnStyle (c);
style.MinAcceptableWidth = 1;
}
}
private void SetMinAcceptableWidth ()
{
var col = GetColumn ();
RunColumnWidthDialog (col, "MinAcceptableWidth", (s,v)=>s.MinAcceptableWidth = v,(s)=>s.MinAcceptableWidth);
}
private void SetMinWidth ()
{
var col = GetColumn ();
RunColumnWidthDialog (col, "MinWidth", (s, v) => s.MinWidth = v, (s) => s.MinWidth);
}
private void SetMaxWidth ()
{
var col = GetColumn ();
RunColumnWidthDialog (col, "MaxWidth", (s, v) => s.MaxWidth = v, (s) => s.MaxWidth);
}
private void RunColumnWidthDialog (DataColumn col, string prompt, Action<ColumnStyle,int> setter,Func<ColumnStyle,int> getter)
{
if (col is null) {
MessageBox.ErrorQuery ("No Table", "No table is currently loaded", "Ok");
return;
}
var accepted = false;
var ok = new Button ("Ok", is_default: true);
ok.Clicked += () => { accepted = true; Application.RequestStop (); };
var cancel = new Button ("Cancel");
cancel.Clicked += () => { Application.RequestStop (); };
var d = new Dialog (prompt, 60, 20, ok, cancel);
var style = tableView.Style.GetOrCreateColumnStyle (col);
var lbl = new Label () {
X = 0,
Y = 1,
Text = col.ColumnName
};
var tf = new TextField () {
Text = getter(style).ToString (),
X = 0,
Y = 2,
Width = Dim.Fill ()
};
d.Add (lbl, tf);
tf.SetFocus ();
Application.Run (d);
if (accepted) {
try {
setter (style, int.Parse (tf.Text.ToString()));
} catch (Exception ex) {
MessageBox.ErrorQuery (60, 20, "Failed to set", ex.Message, "Ok");
}
tableView.Update ();
}
}
private void SetupScrollBar ()
{
var _scrollBar = new ScrollBarView (tableView, true);
_scrollBar.ChangedPosition += () => {
tableView.RowOffset = _scrollBar.Position;
if (tableView.RowOffset != _scrollBar.Position) {
_scrollBar.Position = tableView.RowOffset;
}
tableView.SetNeedsDisplay ();
};
/*
_scrollBar.OtherScrollBarView.ChangedPosition += () => {
_listView.LeftItem = _scrollBar.OtherScrollBarView.Position;
if (_listView.LeftItem != _scrollBar.OtherScrollBarView.Position) {
_scrollBar.OtherScrollBarView.Position = _listView.LeftItem;
}
_listView.SetNeedsDisplay ();
};*/
tableView.DrawContent += (e) => {
_scrollBar.Size = tableView.Table?.Rows?.Count ??0;
_scrollBar.Position = tableView.RowOffset;
// _scrollBar.OtherScrollBarView.Size = _listView.Maxlength - 1;
// _scrollBar.OtherScrollBarView.Position = _listView.LeftItem;
_scrollBar.Refresh ();
};
}
private void TableViewKeyPress (View.KeyEventEventArgs e)
{
if(e.KeyEvent.Key == Key.DeleteChar){
if(tableView.FullRowSelect)
{
// Delete button deletes all rows when in full row mode
foreach(int toRemove in tableView.GetAllSelectedCells().Select(p=>p.Y).Distinct().OrderByDescending(i=>i))
tableView.Table.Rows.RemoveAt(toRemove);
}
else{
// otherwise set all selected cells to null
foreach(var pt in tableView.GetAllSelectedCells())
{
tableView.Table.Rows[pt.Y][pt.X] = DBNull.Value;
}
}
tableView.Update();
e.Handled = true;
}
}
private void ClearColumnStyles ()
{
tableView.Style.ColumnStyles.Clear();
tableView.Update();
}
private void ToggleAlwaysShowHeader ()
{
miAlwaysShowHeaders.Checked = !miAlwaysShowHeaders.Checked;
tableView.Style.AlwaysShowHeaders = miAlwaysShowHeaders.Checked;
tableView.Update();
}
private void ToggleOverline ()
{
miHeaderOverline.Checked = !miHeaderOverline.Checked;
tableView.Style.ShowHorizontalHeaderOverline = miHeaderOverline.Checked;
tableView.Update();
}
private void ToggleHeaderMidline ()
{
miHeaderMidline.Checked = !miHeaderMidline.Checked;
tableView.Style.ShowVerticalHeaderLines = miHeaderMidline.Checked;
tableView.Update();
}
private void ToggleUnderline ()
{
miHeaderUnderline.Checked = !miHeaderUnderline.Checked;
tableView.Style.ShowHorizontalHeaderUnderline = miHeaderUnderline.Checked;
tableView.Update();
}
private void ToggleHorizontalScrollIndicators ()
{
miShowHorizontalScrollIndicators.Checked = !miShowHorizontalScrollIndicators.Checked;
tableView.Style.ShowHorizontalScrollIndicators = miShowHorizontalScrollIndicators.Checked;
tableView.Update();
}
private void ToggleFullRowSelect ()
{
miFullRowSelect.Checked = !miFullRowSelect.Checked;
tableView.FullRowSelect= miFullRowSelect.Checked;
tableView.Update();
}
private void ToggleExpandLastColumn()
{
miExpandLastColumn.Checked = !miExpandLastColumn.Checked;
tableView.Style.ExpandLastColumn = miExpandLastColumn.Checked;
tableView.Update();
}
private void ToggleSmoothScrolling()
{
miSmoothScrolling.Checked = !miSmoothScrolling.Checked;
tableView.Style.SmoothHorizontalScrolling = miSmoothScrolling.Checked;
tableView.Update ();
}
private void ToggleCellLines()
{
miCellLines.Checked = !miCellLines.Checked;
tableView.Style.ShowVerticalCellLines = miCellLines.Checked;
tableView.Update();
}
private void ToggleAllCellLines()
{
tableView.Style.ShowHorizontalHeaderOverline = true;
tableView.Style.ShowVerticalHeaderLines = true;
tableView.Style.ShowHorizontalHeaderUnderline = true;
tableView.Style.ShowVerticalCellLines = true;
miHeaderOverline.Checked = true;
miHeaderMidline.Checked = true;
miHeaderUnderline.Checked = true;
miCellLines.Checked = true;
tableView.Update();
}
private void ToggleNoCellLines()
{
tableView.Style.ShowHorizontalHeaderOverline = false;
tableView.Style.ShowVerticalHeaderLines = false;
tableView.Style.ShowHorizontalHeaderUnderline = false;
tableView.Style.ShowVerticalCellLines = false;
miHeaderOverline.Checked = false;
miHeaderMidline.Checked = false;
miHeaderUnderline.Checked = false;
miCellLines.Checked = false;
tableView.Update();
}
private void ToggleAlternatingColors()
{
//toggle menu item
miAlternatingColors.Checked = !miAlternatingColors.Checked;
if(miAlternatingColors.Checked){
tableView.Style.RowColorGetter = (a)=> {return a.RowIndex%2==0 ? alternatingColorScheme : null;};
}
else
{
tableView.Style.RowColorGetter = null;
}
tableView.SetNeedsDisplay();
}
private void ToggleInvertSelectedCellFirstCharacter ()
{
//toggle menu item
miCursor.Checked = !miCursor.Checked;
tableView.Style.InvertSelectedCellFirstCharacter = miCursor.Checked;
tableView.SetNeedsDisplay ();
}
private void CloseExample ()
{
tableView.Table = null;
}
private void Quit ()
{
Application.RequestStop ();
}
private void OpenExample (bool big)
{
tableView.Table = BuildDemoDataTable(big ? 30 : 5, big ? 1000 : 5);
SetDemoTableStyles();
}
private void OpenUnicodeMap()
{
tableView.Table = BuildUnicodeMap ();
tableView.Update ();
}
private DataTable BuildUnicodeMap ()
{
var dt = new DataTable ();
// add cols called 0 to 9
for (int i = 0; i < 10;i++) {
var col = dt.Columns.Add (i.ToString (), typeof (uint));
var style = tableView.Style.GetOrCreateColumnStyle (col);
style.RepresentationGetter = (o) => new Rune ((uint)o).ToString ();
}
// add cols called a to z
for (int i = 'a'; i < 'a'+26; i++) {
var col =dt.Columns.Add (((char)i).ToString (), typeof (uint));
var style = tableView.Style.GetOrCreateColumnStyle (col);
style.RepresentationGetter = (o) => new Rune ((uint)o).ToString ();
}
// now add table contents
List<uint> runes = new List<uint> ();
foreach(var range in Ranges) {
for(uint i=range.Start;i<=range.End;i++) {
runes.Add (i);
}
}
DataRow dr = null;
for(int i = 0; i<runes.Count;i++) {
if(dr == null || i% dt.Columns.Count == 0) {
dr = dt.Rows.Add ();
}
dr [i % dt.Columns.Count] = runes [i].ToString();
}
return dt;
}
class UnicodeRange {
public uint Start;
public uint End;
public string Category;
public UnicodeRange (uint start, uint end, string category)
{
this.Start = start;
this.End = end;
this.Category = category;
}
}
List<UnicodeRange> Ranges = new List<UnicodeRange> {
new UnicodeRange (0x0000, 0x001F, "ASCII Control Characters"),
new UnicodeRange (0x0080, 0x009F, "C0 Control Characters"),
new UnicodeRange(0x1100, 0x11ff,"Hangul Jamo"), // This is where wide chars tend to start
new UnicodeRange(0x20A0, 0x20CF,"Currency Symbols"),
new UnicodeRange(0x2100, 0x214F,"Letterlike Symbols"),
new UnicodeRange(0x2190, 0x21ff,"Arrows" ),
new UnicodeRange(0x2200, 0x22ff,"Mathematical symbols"),
new UnicodeRange(0x2300, 0x23ff,"Miscellaneous Technical"),
new UnicodeRange(0x2500, 0x25ff,"Box Drawing & Geometric Shapes"),
new UnicodeRange(0x2600, 0x26ff,"Miscellaneous Symbols"),
new UnicodeRange(0x2700, 0x27ff,"Dingbats"),
new UnicodeRange(0x2800, 0x28ff,"Braille"),
new UnicodeRange(0x2b00, 0x2bff,"Miscellaneous Symbols and Arrows"),
new UnicodeRange(0xFB00, 0xFb4f,"Alphabetic Presentation Forms"),
new UnicodeRange(0x12400, 0x1240f,"Cuneiform Numbers and Punctuation"),
new UnicodeRange(0x1FA00, 0x1FA0f,"Chess Symbols"),
new UnicodeRange((uint)(CharMap.MaxCodePointVal - 16), (uint)CharMap.MaxCodePointVal,"End"),
new UnicodeRange (0x0020 ,0x007F ,"Basic Latin"),
new UnicodeRange (0x00A0 ,0x00FF ,"Latin-1 Supplement"),
new UnicodeRange (0x0100 ,0x017F ,"Latin Extended-A"),
new UnicodeRange (0x0180 ,0x024F ,"Latin Extended-B"),
new UnicodeRange (0x0250 ,0x02AF ,"IPA Extensions"),
new UnicodeRange (0x02B0 ,0x02FF ,"Spacing Modifier Letters"),
new UnicodeRange (0x0300 ,0x036F ,"Combining Diacritical Marks"),
new UnicodeRange (0x0370 ,0x03FF ,"Greek and Coptic"),
new UnicodeRange (0x0400 ,0x04FF ,"Cyrillic"),
new UnicodeRange (0x0500 ,0x052F ,"Cyrillic Supplementary"),
new UnicodeRange (0x0530 ,0x058F ,"Armenian"),
new UnicodeRange (0x0590 ,0x05FF ,"Hebrew"),
new UnicodeRange (0x0600 ,0x06FF ,"Arabic"),
new UnicodeRange (0x0700 ,0x074F ,"Syriac"),
new UnicodeRange (0x0780 ,0x07BF ,"Thaana"),
new UnicodeRange (0x0900 ,0x097F ,"Devanagari"),
new UnicodeRange (0x0980 ,0x09FF ,"Bengali"),
new UnicodeRange (0x0A00 ,0x0A7F ,"Gurmukhi"),
new UnicodeRange (0x0A80 ,0x0AFF ,"Gujarati"),
new UnicodeRange (0x0B00 ,0x0B7F ,"Oriya"),
new UnicodeRange (0x0B80 ,0x0BFF ,"Tamil"),
new UnicodeRange (0x0C00 ,0x0C7F ,"Telugu"),
new UnicodeRange (0x0C80 ,0x0CFF ,"Kannada"),
new UnicodeRange (0x0D00 ,0x0D7F ,"Malayalam"),
new UnicodeRange (0x0D80 ,0x0DFF ,"Sinhala"),
new UnicodeRange (0x0E00 ,0x0E7F ,"Thai"),
new UnicodeRange (0x0E80 ,0x0EFF ,"Lao"),
new UnicodeRange (0x0F00 ,0x0FFF ,"Tibetan"),
new UnicodeRange (0x1000 ,0x109F ,"Myanmar"),
new UnicodeRange (0x10A0 ,0x10FF ,"Georgian"),
new UnicodeRange (0x1100 ,0x11FF ,"Hangul Jamo"),
new UnicodeRange (0x1200 ,0x137F ,"Ethiopic"),
new UnicodeRange (0x13A0 ,0x13FF ,"Cherokee"),
new UnicodeRange (0x1400 ,0x167F ,"Unified Canadian Aboriginal Syllabics"),
new UnicodeRange (0x1680 ,0x169F ,"Ogham"),
new UnicodeRange (0x16A0 ,0x16FF ,"Runic"),
new UnicodeRange (0x1700 ,0x171F ,"Tagalog"),
new UnicodeRange (0x1720 ,0x173F ,"Hanunoo"),
new UnicodeRange (0x1740 ,0x175F ,"Buhid"),
new UnicodeRange (0x1760 ,0x177F ,"Tagbanwa"),
new UnicodeRange (0x1780 ,0x17FF ,"Khmer"),
new UnicodeRange (0x1800 ,0x18AF ,"Mongolian"),
new UnicodeRange (0x1900 ,0x194F ,"Limbu"),
new UnicodeRange (0x1950 ,0x197F ,"Tai Le"),
new UnicodeRange (0x19E0 ,0x19FF ,"Khmer Symbols"),
new UnicodeRange (0x1D00 ,0x1D7F ,"Phonetic Extensions"),
new UnicodeRange (0x1E00 ,0x1EFF ,"Latin Extended Additional"),
new UnicodeRange (0x1F00 ,0x1FFF ,"Greek Extended"),
new UnicodeRange (0x2000 ,0x206F ,"General Punctuation"),
new UnicodeRange (0x2070 ,0x209F ,"Superscripts and Subscripts"),
new UnicodeRange (0x20A0 ,0x20CF ,"Currency Symbols"),
new UnicodeRange (0x20D0 ,0x20FF ,"Combining Diacritical Marks for Symbols"),
new UnicodeRange (0x2100 ,0x214F ,"Letterlike Symbols"),
new UnicodeRange (0x2150 ,0x218F ,"Number Forms"),
new UnicodeRange (0x2190 ,0x21FF ,"Arrows"),
new UnicodeRange (0x2200 ,0x22FF ,"Mathematical Operators"),
new UnicodeRange (0x2300 ,0x23FF ,"Miscellaneous Technical"),
new UnicodeRange (0x2400 ,0x243F ,"Control Pictures"),
new UnicodeRange (0x2440 ,0x245F ,"Optical Character Recognition"),
new UnicodeRange (0x2460 ,0x24FF ,"Enclosed Alphanumerics"),
new UnicodeRange (0x2500 ,0x257F ,"Box Drawing"),
new UnicodeRange (0x2580 ,0x259F ,"Block Elements"),
new UnicodeRange (0x25A0 ,0x25FF ,"Geometric Shapes"),
new UnicodeRange (0x2600 ,0x26FF ,"Miscellaneous Symbols"),
new UnicodeRange (0x2700 ,0x27BF ,"Dingbats"),
new UnicodeRange (0x27C0 ,0x27EF ,"Miscellaneous Mathematical Symbols-A"),
new UnicodeRange (0x27F0 ,0x27FF ,"Supplemental Arrows-A"),
new UnicodeRange (0x2800 ,0x28FF ,"Braille Patterns"),
new UnicodeRange (0x2900 ,0x297F ,"Supplemental Arrows-B"),
new UnicodeRange (0x2980 ,0x29FF ,"Miscellaneous Mathematical Symbols-B"),
new UnicodeRange (0x2A00 ,0x2AFF ,"Supplemental Mathematical Operators"),
new UnicodeRange (0x2B00 ,0x2BFF ,"Miscellaneous Symbols and Arrows"),
new UnicodeRange (0x2E80 ,0x2EFF ,"CJK Radicals Supplement"),
new UnicodeRange (0x2F00 ,0x2FDF ,"Kangxi Radicals"),
new UnicodeRange (0x2FF0 ,0x2FFF ,"Ideographic Description Characters"),
new UnicodeRange (0x3000 ,0x303F ,"CJK Symbols and Punctuation"),
new UnicodeRange (0x3040 ,0x309F ,"Hiragana"),
new UnicodeRange (0x30A0 ,0x30FF ,"Katakana"),
new UnicodeRange (0x3100 ,0x312F ,"Bopomofo"),
new UnicodeRange (0x3130 ,0x318F ,"Hangul Compatibility Jamo"),
new UnicodeRange (0x3190 ,0x319F ,"Kanbun"),
new UnicodeRange (0x31A0 ,0x31BF ,"Bopomofo Extended"),
new UnicodeRange (0x31F0 ,0x31FF ,"Katakana Phonetic Extensions"),
new UnicodeRange (0x3200 ,0x32FF ,"Enclosed CJK Letters and Months"),
new UnicodeRange (0x3300 ,0x33FF ,"CJK Compatibility"),
new UnicodeRange (0x3400 ,0x4DBF ,"CJK Unified Ideographs Extension A"),
new UnicodeRange (0x4DC0 ,0x4DFF ,"Yijing Hexagram Symbols"),
new UnicodeRange (0x4E00 ,0x9FFF ,"CJK Unified Ideographs"),
new UnicodeRange (0xA000 ,0xA48F ,"Yi Syllables"),
new UnicodeRange (0xA490 ,0xA4CF ,"Yi Radicals"),
new UnicodeRange (0xAC00 ,0xD7AF ,"Hangul Syllables"),
new UnicodeRange (0xD800 ,0xDB7F ,"High Surrogates"),
new UnicodeRange (0xDB80 ,0xDBFF ,"High Private Use Surrogates"),
new UnicodeRange (0xDC00 ,0xDFFF ,"Low Surrogates"),
new UnicodeRange (0xE000 ,0xF8FF ,"Private Use Area"),
new UnicodeRange (0xF900 ,0xFAFF ,"CJK Compatibility Ideographs"),
new UnicodeRange (0xFB00 ,0xFB4F ,"Alphabetic Presentation Forms"),
new UnicodeRange (0xFB50 ,0xFDFF ,"Arabic Presentation Forms-A"),
new UnicodeRange (0xFE00 ,0xFE0F ,"Variation Selectors"),
new UnicodeRange (0xFE20 ,0xFE2F ,"Combining Half Marks"),
new UnicodeRange (0xFE30 ,0xFE4F ,"CJK Compatibility Forms"),
new UnicodeRange (0xFE50 ,0xFE6F ,"Small Form Variants"),
new UnicodeRange (0xFE70 ,0xFEFF ,"Arabic Presentation Forms-B"),
new UnicodeRange (0xFF00 ,0xFFEF ,"Halfwidth and Fullwidth Forms"),
new UnicodeRange (0xFFF0 ,0xFFFF ,"Specials"),
new UnicodeRange (0x10000, 0x1007F ,"Linear B Syllabary"),
new UnicodeRange (0x10080, 0x100FF ,"Linear B Ideograms"),
new UnicodeRange (0x10100, 0x1013F ,"Aegean Numbers"),
new UnicodeRange (0x10300, 0x1032F ,"Old Italic"),
new UnicodeRange (0x10330, 0x1034F ,"Gothic"),
new UnicodeRange (0x10380, 0x1039F ,"Ugaritic"),
new UnicodeRange (0x10400, 0x1044F ,"Deseret"),
new UnicodeRange (0x10450, 0x1047F ,"Shavian"),
new UnicodeRange (0x10480, 0x104AF ,"Osmanya"),
new UnicodeRange (0x10800, 0x1083F ,"Cypriot Syllabary"),
new UnicodeRange (0x1D000, 0x1D0FF ,"Byzantine Musical Symbols"),
new UnicodeRange (0x1D100, 0x1D1FF ,"Musical Symbols"),
new UnicodeRange (0x1D300, 0x1D35F ,"Tai Xuan Jing Symbols"),
new UnicodeRange (0x1D400, 0x1D7FF ,"Mathematical Alphanumeric Symbols"),
new UnicodeRange (0x1F600, 0x1F532 ,"Emojis Symbols"),
new UnicodeRange (0x20000, 0x2A6DF ,"CJK Unified Ideographs Extension B"),
new UnicodeRange (0x2F800, 0x2FA1F ,"CJK Compatibility Ideographs Supplement"),
new UnicodeRange (0xE0000, 0xE007F ,"Tags"),
};
private void SetDemoTableStyles ()
{
var alignMid = new TableView.ColumnStyle () {
Alignment = TextAlignment.Centered
};
var alignRight = new TableView.ColumnStyle () {
Alignment = TextAlignment.Right
};
var dateFormatStyle = new TableView.ColumnStyle () {
Alignment = TextAlignment.Right,
RepresentationGetter = (v)=> v is DateTime d ? d.ToString("yyyy-MM-dd"):v.ToString()
};
var negativeRight = new TableView.ColumnStyle () {
Format = "0.##",
MinWidth = 10,
AlignmentGetter = (v)=>v is double d ?
// align negative values right
d < 0 ? TextAlignment.Right :
// align positive values left
TextAlignment.Left:
// not a double
TextAlignment.Left,
ColorGetter = (a)=> a.CellValue is double d ?
// color 0 and negative values red
d <= 0.0000001 ? a.RowIndex%2==0 && miAlternatingColors.Checked ? redColorSchemeAlt: redColorScheme :
// use normal scheme for positive values
null:
// not a double
null
};
tableView.Style.ColumnStyles.Add(tableView.Table.Columns["DateCol"],dateFormatStyle);
tableView.Style.ColumnStyles.Add(tableView.Table.Columns["DoubleCol"],negativeRight);
tableView.Style.ColumnStyles.Add(tableView.Table.Columns["NullsCol"],alignMid);
tableView.Style.ColumnStyles.Add(tableView.Table.Columns["IntCol"],alignRight);
tableView.Update();
}
private void OpenSimple (bool big)
{
tableView.Table = BuildSimpleDataTable(big ? 30 : 5, big ? 1000 : 5);
}
private void EditCurrentCell (TableView.CellActivatedEventArgs e)
{
if(e.Table == null)
return;
var o = e.Table.Rows [e.Row] [e.Col];
var title = o is uint u ? GetUnicodeCategory(u) + $"(0x{o:X4})" : "Enter new value";
var oldValue = e.Table.Rows[e.Row][e.Col].ToString();
bool okPressed = false;
var ok = new Button ("Ok", is_default: true);
ok.Clicked += () => { okPressed = true; Application.RequestStop (); };
var cancel = new Button ("Cancel");
cancel.Clicked += () => { Application.RequestStop (); };
var d = new Dialog (title, 60, 20, ok, cancel);
var lbl = new Label() {
X = 0,
Y = 1,
Text = e.Table.Columns[e.Col].ColumnName
};
var tf = new TextField()
{
Text = oldValue,
X = 0,
Y = 2,
Width = Dim.Fill()
};
d.Add (lbl,tf);
tf.SetFocus();
Application.Run (d);
if(okPressed) {
try {
e.Table.Rows[e.Row][e.Col] = string.IsNullOrWhiteSpace(tf.Text.ToString()) ? DBNull.Value : (object)tf.Text;
}
catch(Exception ex) {
MessageBox.ErrorQuery(60,20,"Failed to set text", ex.Message,"Ok");
}
tableView.Update();
}
}
private string GetUnicodeCategory (uint u)
{
return Ranges.FirstOrDefault (r => u >= r.Start && u <= r.End)?.Category ?? "Unknown";
}
/// <summary>
/// Generates a new demo <see cref="DataTable"/> with the given number of <paramref name="cols"/> (min 5) and <paramref name="rows"/>
/// </summary>
/// <param name="cols"></param>
/// <param name="rows"></param>
/// <returns></returns>
public static DataTable BuildDemoDataTable(int cols, int rows)
{
var dt = new DataTable();
int explicitCols = 6;
dt.Columns.Add(new DataColumn("StrCol",typeof(string)));
dt.Columns.Add(new DataColumn("DateCol",typeof(DateTime)));
dt.Columns.Add(new DataColumn("IntCol",typeof(int)));
dt.Columns.Add(new DataColumn("DoubleCol",typeof(double)));
dt.Columns.Add(new DataColumn("NullsCol",typeof(string)));
dt.Columns.Add(new DataColumn("Unicode",typeof(string)));
for(int i=0;i< cols -explicitCols; i++) {
dt.Columns.Add("Column" + (i+explicitCols));
}
var r = new Random(100);
for(int i=0;i< rows;i++) {
List<object> row = new List<object>(){
"Some long text that is super cool",
new DateTime(2000+i,12,25),
r.Next(i),
(r.NextDouble()*i)-0.5 /*add some negatives to demo styles*/,
DBNull.Value,
"Les Mise" + Char.ConvertFromUtf32(Int32.Parse("0301", NumberStyles.HexNumber)) + "rables"
};
for(int j=0;j< cols -explicitCols; j++) {
row.Add("SomeValue" + r.Next(100));
}
dt.Rows.Add(row.ToArray());
}
return dt;
}
/// <summary>
/// Builds a simple table in which cell values contents are the index of the cell. This helps testing that scrolling etc is working correctly and not skipping out any rows/columns when paging
/// </summary>
/// <param name="cols"></param>
/// <param name="rows"></param>
/// <returns></returns>
public static DataTable BuildSimpleDataTable(int cols, int rows)
{
var dt = new DataTable();
for(int c = 0; c < cols; c++) {
dt.Columns.Add("Col"+c);
}
for(int r = 0; r < rows; r++) {
var newRow = dt.NewRow();
for(int c = 0; c < cols; c++) {
newRow[c] = $"R{r}C{c}";
}
dt.Rows.Add(newRow);
}
return dt;
}
}
}
|
using System;
using UnityEngine;
using UnityEditor;
using Unity.Mathematics;
using static Unity.Mathematics.math;
namespace IzBone.IzBCollider {
using Common;
[CanEditMultipleObjects]
[CustomEditor(typeof(BodyAuthoring))]
sealed class BodyAutoringInspector : Editor
{
void OnSceneGUI() {
var tgt = (BodyAuthoring)target;
tgt.DEBUG_drawGizmos();
}
public override void OnInspectorGUI() {
serializedObject.Update();
// 形状タイプ
var sfMode = serializedObject.FindProperty( "_shapeType" );
EditorGUILayout.PropertyField( sfMode );
var mode = (ShapeType)sfMode.enumValueIndex;
// 中心位置オフセット
var sfCenter = serializedObject.FindProperty( "_center" );
EditorGUILayout.PropertyField( sfCenter );
// 半径
var sfR = serializedObject.FindProperty( "_r" );
var sfRX = sfR.FindPropertyRelative("x");
var sfRY = sfR.FindPropertyRelative("y");
var sfRZ = sfR.FindPropertyRelative("z");
if (mode == ShapeType.Sphere) {
using (new EditorGUIUtility8.MixedValueScope(sfR))
using (var check = new EditorGUI.ChangeCheckScope()) {
var r = EditorGUILayout.FloatField( "Radius", sfRX.floatValue );
if (check.changed) sfRX.floatValue = r;
}
} else if (mode == ShapeType.Capsule) {
using (var check = new EditorGUI.ChangeCheckScope()) {
var r = EditorGUILayout.FloatField( "Radius", sfRX.floatValue );
var h = EditorGUILayout.FloatField( "Height", sfRY.floatValue*2 );
if (check.changed) {
sfRX.floatValue = r;
sfRY.floatValue = h/2;
}
}
} else if (mode == ShapeType.Box) {
using (var check = new EditorGUI.ChangeCheckScope()) {
var r = new Vector3(sfRX.floatValue, sfRY.floatValue, sfRZ.floatValue);
r = EditorGUILayout.Vector3Field( "Size", r*2 );
if (check.changed) {
sfRX.floatValue = r.x/2;
sfRY.floatValue = r.y/2;
sfRZ.floatValue = r.z/2;
}
}
} else if (mode == ShapeType.Plane) {
} else { throw new InvalidProgramException(); }
// 回転
if (mode != ShapeType.Sphere) {
var sfRot = serializedObject.FindProperty( "_rot" );
using (var check = new EditorGUI.ChangeCheckScope()) {
var rot = getPropQuaternion(sfRot);
var euler = rot.eulerAngles;
euler = EditorGUILayout.Vector3Field("Rotation", euler);
if (check.changed)
setPropQuaternion( sfRot, Quaternion.Euler(euler) );
}
}
serializedObject.ApplyModifiedProperties();
}
Quaternion getPropQuaternion(SerializedProperty prop) =>
new Quaternion(
prop.FindPropertyRelative("value.x").floatValue,
prop.FindPropertyRelative("value.y").floatValue,
prop.FindPropertyRelative("value.z").floatValue,
prop.FindPropertyRelative("value.w").floatValue
);
void setPropFloat4(SerializedProperty prop, float4 v) {
prop.FindPropertyRelative("x").floatValue = v.x;
prop.FindPropertyRelative("y").floatValue = v.y;
prop.FindPropertyRelative("z").floatValue = v.z;
prop.FindPropertyRelative("w").floatValue = v.w;
}
void setPropQuaternion(SerializedProperty prop, quaternion q) {
setPropFloat4(prop.FindPropertyRelative("value"), q.value);
}
}
}
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
[Serializable]
public class WinConditions
{
public BitArray _conditions;
public List<WinRate> _winRate = new List<WinRate>();
}
public class WinRate
{
public int count;
public float rate;
}
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class pickupController : MonoBehaviour
{
bool pickedUp = false;
private void FixedUpdate()
{
if (pickedUp)
{
transform.localScale *= 0.9f;
if (transform.localScale.magnitude <= 0.1f) Destroy(gameObject);
}
}
private void OnTriggerEnter(Collider other)
{
if (other.tag == "Player") pickedUp = true;
GameObject.FindGameObjectWithTag("GameController").GetComponent<GameController>().emotionCount++;
GetComponent<SphereCollider>().enabled = false;
GetComponent<AudioSource>().Play();
}
}
|
namespace PhotonInMaze.GameCamera {
internal enum GameCameraType {
Area,
AbovePhoton,
Zoomed,
Moved,
BetweenPhotonAndArrow
}
} |
using UnityEngine;
using UnityEngine.UI;
public class EmoteBubble : MonoBehaviour {
[SerializeField]
private Image _emoteIconImg = null;
[SerializeField]
private Tooltip _tooltip = null;
[SerializeField]
private EmoteIcon[] icons = null;
private float timer;
private Emote currentEmote;
private void Awake() {
this.setBubbleVisible(false);
}
private void Update() {
if(!Pause.isPaused()) {
if(this.timer > 0) {
this.timer -= Time.deltaTime;
if(this.timer <= 0) {
this.cancelEmote();
}
}
}
}
public void startEmote(Emote emote) {
if(this.currentEmote != null && (this.currentEmote.isPriority && !emote.isPriority)) {
return;
}
this.currentEmote = emote;
this.timer = emote.timeVisible;
Sprite sprite = null;
foreach(EmoteIcon icon in this.icons) {
if(icon != null && emote.iconName == icon.emoteName) {
sprite = icon.icon;
}
}
if(sprite == null ) {
Debug.LogWarning("Could not found emote icon with name " + emote.iconName);
}
this._emoteIconImg.sprite = sprite;
if(!string.IsNullOrEmpty(emote.tooltip)) {
this._tooltip.text = emote.tooltip;
}
this.setBubbleVisible(true);
}
public void cancelEmote() {
this._tooltip.text = string.Empty;
this.setBubbleVisible(false);
this.currentEmote = null;
}
private void setBubbleVisible(bool visible) {
this._emoteIconImg.gameObject.SetActive(visible);
}
}
|
/*
* Author: Easton Bolinger
* Class: SodaFlavor.cs
* Purpose: An enum holding soda flavor options
*/
using System;
using System.Collections.Generic;
using System.Text;
namespace CowboyCafe.Data
{
/// <summary>
/// Enum holding all soda flavor options
/// </summary>
public enum SodaFlavor
{
CreamSoda,
OrangeSoda,
Sarsparilla,
BirchBeer,
RootBeer
}
}
|
using UnityEngine;
using UnityEditor;
public class ReplaceSelectionEditorWindow : EditorWindow {
GameObject target;
[MenuItem("Window/Replace Selection")]
private static void ShowWindow() {
var window = GetWindow<ReplaceSelectionEditorWindow>();
window.titleContent = new GUIContent("Replace Selection");
window.Show();
}
private void OnGUI() {
target = (GameObject)EditorGUILayout.ObjectField(target, typeof(GameObject), true);
GUILayout.Space(16);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Replace selection", GUILayout.Width(140), GUILayout.Height(40))) {
// FIXME: doesnt preserve prefab link
// ReplaceSelection();
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
private void ReplaceSelection() {
if (!target)
return;
var selection = Selection.GetTransforms(
SelectionMode.TopLevel | SelectionMode.Editable
);
// Undo.RecordObjects(selection, "deleted selection");
foreach (var item in selection) {
var newItem =
// FIXME: prefabs not instantiated by prefab utility
// (GameObject)PrefabUtility.InstantiatePrefab(target);
Instantiate(target, item.position, item.rotation, item.parent);
newItem.transform.localScale = item.localScale;
Undo.RegisterCreatedObjectUndo(newItem, "created replacement object");
Undo.DestroyObjectImmediate(item.gameObject);
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace Mega_Desk
{
public partial class SearchQuotes : Form
{
public string criteria;
List<string> materialsList = new List<string>();
public SearchQuotes()
{
InitializeComponent();
//get the materials from the material/cost dictionary
//and store them in a list for simpilier access in the ListBox
int count = 0;
foreach (string item in Constants.materialCost.Keys)
{
materialsList.Add(Constants.materialCost.Keys.ElementAt(count));
count++;
}
//populate the materials ListBox with values from the list
materialListBox.DataSource = materialsList;
}
private void cancelButton_Click(object sender, EventArgs e)
{
criteria = "";
Close();
}
private void searchButton_Click(object sender, EventArgs e)
{
criteria = materialListBox.SelectedItem.ToString();
Close();
}
}
}
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using AbilityClasses;
using AudioClasses;
[System.Serializable]
[CreateAssetMenu(fileName = "New Player Class", menuName = "Game/Player Class")]
public class PlayerClass : ScriptableObject
{
//Classname
[SerializeField] string className;
public string Name { get { return className; } }
//Class Description
[TextArea]
[SerializeField]
string description;
public string Description { get { return description; } }
[SerializeField] int health;
public int Health { get { return health; } }
//List of the Base abilities offered by the class.
[SerializeField] List<AbilityObject> baseAbilities;
public List<AbilityObject> BaseAbilities { get { return baseAbilities; } }
//Adding in the link to the player prefab that will contain the Camera, Arms, and Animator/tions to run the player. -Conner
[SerializeField] EntityContainer classCamera;
public EntityContainer ClassCamera { get { return classCamera; } }
[SerializeField] SoundEffect walkingSound;
public SoundEffect WalkingSound { get { return walkingSound; } private set { walkingSound = value; } }
[SerializeField] SoundEffect hitSound;
public SoundEffect HitSound { get { return hitSound; } private set { hitSound = value; } }
[SerializeField] SoundEffect hurtSound;
public SoundEffect HurtSound { get { return hurtSound; } private set { hurtSound = value; } }
[SerializeField] SoundEffect deathSound;
public SoundEffect DeathSound { get { return deathSound; } private set { deathSound = value; } }
}
|
using WebApplication1.EfStuff.Model.Energy;
using WebApplication1.EfStuff.Repositoryies.Energy.Intrefaces;
namespace WebApplication1.EfStuff.Repositoryies.Energy
{
public class ElectricBillRepository : BaseRepository<ElectricBill>, IElectricBillRepository
{
public ElectricBillRepository(KzDbContext kzDbContext) : base(kzDbContext) { }
}
}
|
using Azure.Cosmos;
using AzureAI.CognitiveSearch.CustomSkills.Infrastructure.Model;
using AzureAI.CognitiveSearch.CustomSkills.Infrastructure.Services.Data.Interfaces;
using AzureAI.CognitiveSearch.CustomSkills.Infrastructure.Settings;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;
namespace AzureAI.CognitiveSearch.CustomSkills.Infrastructure.Services.Data
{
public sealed class CosmosDbDataService<T> : IDataService<T> where T : class, IEntity
{
private readonly CosmosDbSettings _dataServiceConfiguration;
private readonly CosmosClient _client;
private readonly ILogger<CosmosDbDataService<T>> _logger;
public CosmosDbDataService(CosmosDbSettings dataServiceConfiguration, CosmosClient client,
ILogger<CosmosDbDataService<T>> logger)
{
_dataServiceConfiguration = dataServiceConfiguration;
_client = client;
_logger = logger;
}
public async Task<T> AddAsync(T newEntity)
{
try
{
var container = GetContainer();
newEntity.Id = Guid.NewGuid();
ItemResponse<T> createResponse = await container.CreateItemAsync(newEntity);
return createResponse.Value;
}
catch (CosmosException ex)
{
_logger.LogError($"New entity with ID: {newEntity.Id} was not added successfully - error details: {ex.Message}");
throw;
}
}
private CosmosContainer GetContainer()
{
var database = _client.GetDatabase(_dataServiceConfiguration.DatabaseName);
var container = database.GetContainer(_dataServiceConfiguration.ContainerName);
return container;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using Cirrious.FluentLayouts.Touch;
using CoreGraphics;
using Foundation;
using ResidentAppCross.ViewModels;
using UIKit;
namespace ResidentAppCross.iOS.Views
{
public class BaseForm<T> : ViewBase<T>, IScrollableView where T : ViewModelBase
{
private UIScrollView _sectionsContainer;
private KeyboardViewScroller _scroll;
private List<UIView> _content;
private List<NSObject> _notificatioHandlers;
private NSObject keyboardShowObserver;
private NSObject keyboardHideObserver;
private bool _heyboardShown;
private List<UIGestureRecognizer> _sectionsContainerGestureRecognizers;
private bool _sectionContainerGesturesEnabled = true;
public BaseForm(string nibName, NSBundle bundle) : base(nibName, bundle)
{
}
public BaseForm() : base(null, null)
{
}
public virtual UIView HeaderView { get; set; }
public virtual UIView FooterView { get; set; }
public virtual float VerticalSectionsSpacing { get; set; } = 15f;
public List<UIGestureRecognizer> SectionsContainerGestureRecognizers
{
get { return _sectionsContainerGestureRecognizers ?? (_sectionsContainerGestureRecognizers = new List<UIGestureRecognizer>(SectionsContainer.GestureRecognizers)); }
set { _sectionsContainerGestureRecognizers = value; }
}
public bool SectionContainerGesturesEnabled
{
get { return _sectionContainerGesturesEnabled; }
set
{
_sectionContainerGesturesEnabled = value;
if (value)
{
foreach (
var recognizer in
SectionsContainerGestureRecognizers.Except(SectionsContainer.GestureRecognizers))
{
SectionsContainer.AddGestureRecognizer(recognizer);
}
}
else
{
foreach (var uiGestureRecognizer in SectionsContainer.GestureRecognizers)
{
SectionsContainer.RemoveGestureRecognizer(uiGestureRecognizer);
}
}
}
}
public UIScrollView SectionsContainer
{
get
{
if (_sectionsContainer == null)
{
EdgesForExtendedLayout = UIRectEdge.None;
View.BackgroundColor = AppTheme.DeepBackgroundColor;
_sectionsContainer = new UIScrollView().AddTo(View);
_sectionsContainer.TranslatesAutoresizingMaskIntoConstraints = false;
_sectionsContainer.BackgroundColor = AppTheme.DeepBackgroundColor;
// if (HeaderView != null)
// {
//
// }
View.AddConstraints(
_sectionsContainer.AtRightOf(View),
_sectionsContainer.AtLeftOf(View));
if (HeaderView == null)
{
View.AddConstraints(_sectionsContainer.AtTopOf(View));
}
else
{
View.Add(HeaderView);
View.AddConstraints(
HeaderView.AtRightOf(View),
HeaderView.AtLeftOf(View),
HeaderView.AtTopOf(View),
_sectionsContainer.Below(HeaderView));
}
if (FooterView == null)
{
View.AddConstraints(_sectionsContainer.AtBottomOf(View));
}
else
{
View.Add(FooterView);
View.AddConstraints(
FooterView.AtRightOf(View),
FooterView.AtLeftOf(View),
FooterView.AtBottomOf(View),
_sectionsContainer.Above(FooterView));
}
}
return _sectionsContainer;
}
set { _sectionsContainer = value; }
}
public void SetCustomBackground(UIColor color)
{
View.BackgroundColor = color;
SectionsContainer.BackgroundColor = UIColor.Clear;
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
SectionsContainer.AddGestureRecognizer(new UITapGestureRecognizer(SectionContainerTapped));
BindForm();
RefreshContent();
}
private void SectionContainerTapped()
{
foreach (var uiView in Content.OfType<IFormTapListener>()) uiView.FormTapped();
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
RegisterNotificationHandlers();
foreach (var uiView in Content.OfType<IFormEventsListener>()) uiView.FormDidAppear();
}
public override void ViewDidDisappear(bool animated)
{
base.ViewDidDisappear(animated);
foreach (var uiView in Content.OfType<IFormEventsListener>()) uiView.FormDidDisappear();
}
public override void ViewWillAppear(bool animated)
{
base.ViewWillAppear(animated);
foreach (var uiView in Content.OfType<IFormEventsListener>()) uiView.FormWillAppear();
// keyboardShowObserver = NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillShowNotification, (notification) => {
//
// NSValue nsKeyboardBounds = (NSValue)notification.UserInfo.ObjectForKey(UIKeyboard.BoundsUserInfoKey);
// RectangleF keyboardBounds = nsKeyboardBounds.RectangleFValue;
// var height = View.Bounds.Height - keyboardBounds.Height;
// if (NavigationController != null && NavigationController.TabBarController != null && NavigationController.TabBarController.TabBar != null)
// {
// // Re-add tab bar height since it is hidden under keyboard but still excluded from View.Bounds.Height.
// height += NavigationController.TabBarController.TabBar.Frame.Height;
// }
//
// SectionsContainer.Frame = new CGRect(SectionsContainer.Frame.Location, new SizeF((float) View.Bounds.Width, (float) height));
// });
//
// keyboardHideObserver = NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillHideNotification, (notification) => {
//
// UIApplication.EnsureUIThread();
// SectionsContainer.Frame = new CGRect(SectionsContainer.Frame.Location, View.Bounds.Size);
// });
}
public override void ViewWillDisappear(bool animated)
{
base.ViewWillDisappear(animated);
UnregisterNotificationHandlers();
foreach (var uiView in Content.OfType<IFormEventsListener>()) uiView.FormWillDisappear();
}
protected List<NSObject> NotificatioHandlers
{
get { return _notificatioHandlers ?? (_notificatioHandlers = new List<NSObject>()); }
set { _notificatioHandlers = value; }
}
public float ShownKeyboardHeight { get; set; }
public bool HeyboardShown
{
get { return _heyboardShown; }
set
{
if (_heyboardShown == value) return;
_heyboardShown = value;
foreach (var result in Content.OfType<ISoftKeyboardEventsListener>())
{
if (value) result.DidShowKeyboard();
else result.DidHideKeyboard();
}
}
}
protected virtual void RegisterNotificationHandlers()
{
NotificatioHandlers.Add(NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillShowNotification,
new Action<NSNotification>(
notification =>
{
CGRect overridenRect = CGRect.Empty;
foreach (var result in Content.OfType<ISoftKeyboardEventsListener>())
{
result.WillShowKeyboard(ref overridenRect);
}
ShownKeyboardHeight = (float) UIKeyboard.FrameBeginFromNotification(notification).Height;
var duration = UIKeyboard.AnimationDurationFromNotification(notification);
UIViewAnimationCurve curve =
(UIViewAnimationCurve) UIKeyboard.AnimationCurveFromNotification(notification);
if (overridenRect != CGRect.Empty)
{
ScrollViewTo(overridenRect, duration, curve);
}
else
{
ScrollViewBy(ShownKeyboardHeight, duration, curve);
}
})));
NotificatioHandlers.Add(NSNotificationCenter.DefaultCenter.AddObserver(
UIKeyboard.DidChangeFrameNotification,
notification => { }));
NotificatioHandlers.Add(NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillHideNotification,
new Action<NSNotification>(
notification =>
{
//foreach (var uiView in Content.OfType<IFormEventsListener>()) uiView.WillHideNotification();
CGRect overridenRect = CGRect.Empty;
foreach (var result in Content.OfType<ISoftKeyboardEventsListener>())
{
result.WillHideKeyboard(ref overridenRect);
}
var suppliedHeight = (float) UIKeyboard.FrameBeginFromNotification(notification).Height;
var duration = UIKeyboard.AnimationDurationFromNotification(notification);
UIViewAnimationCurve curve =
(UIViewAnimationCurve) UIKeyboard.AnimationCurveFromNotification(notification);
var frame = SectionsContainer.Frame;
frame.Height += ShownKeyboardHeight;
SectionsContainer.Frame = frame;
if (overridenRect != CGRect.Empty)
{
ScrollViewTo(overridenRect, duration, curve);
}
else
{
ScrollViewBy(-ShownKeyboardHeight, duration, curve);
}
})));
NotificatioHandlers.Add(NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.DidShowNotification,
notification =>
{
return;
if (HeyboardShown) return;
var frame = SectionsContainer.Frame;
frame.Height -= ShownKeyboardHeight;
SectionsContainer.Frame = frame;
HeyboardShown = true;
}));
NotificatioHandlers.Add(NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.DidHideNotification,
notification => { HeyboardShown = false; }));
NotificatioHandlers.Add(NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillChangeFrameNotification,
notification =>
{
var suppliedHeight = (float)UIKeyboard.FrameBeginFromNotification(notification).Height;
}));
}
private void ScrollViewBy(float height, double duration, UIViewAnimationCurve curve)
{
UIView.BeginAnimations(null);
UIView.SetAnimationDuration(duration);
UIView.SetAnimationCurve(curve);
var frame = SectionsContainer.ContentOffset;
frame.Y += height;
if (frame.Y < 0) frame.Y = 0;
// else if (frame.Y > SectionsContainer.ContentSize.Height)
// frame.Y = SectionsContainer.ContentSize.Height - SectionsContainer.Frame.Height;
SectionsContainer.ContentOffset = frame;
UIView.CommitAnimations();
}
private void ScrollViewTo(CGRect rect, double duration, UIViewAnimationCurve curve)
{
UIView.BeginAnimations(null);
UIView.SetAnimationDuration(duration);
UIView.SetAnimationCurve(curve);
var frame = SectionsContainer.ContentOffset;
frame.Y = rect.Y;
SectionsContainer.ContentOffset = frame;
UIView.CommitAnimations();
}
protected virtual void UnregisterNotificationHandlers()
{
foreach (var notificatioHandler in NotificatioHandlers.ToArray())
{
NSNotificationCenter.DefaultCenter.RemoveObserver(notificatioHandler);
}
NotificatioHandlers.Clear();
}
public virtual void BindForm()
{
}
public virtual void UnbindForm()
{
}
public virtual void RefreshContent()
{
foreach (var subview in SectionsContainer.Subviews.ToArray())
{
subview.RemoveFromSuperview();
}
SectionsContainer.RemoveConstraints(SectionsContainer.Constraints);
Content.Clear();
GetContent(Content);
foreach (var uiView in Content)
{
var section = uiView as SectionViewBase;
if (section != null) section.ParentController = this;
SectionsContainer.Add(uiView);
}
LayoutContent();
}
public virtual void LayoutContent()
{
if (!SectionsContainer.Subviews.Any()) return;
var constraints = SectionsContainer.VerticalStackPanelConstraints(
new Margins(0, 0, 0, 25f, 0, AppTheme.FormSectionVerticalSpacing),
SectionsContainer.Subviews).ToArray();
var subviews = SectionsContainer.Subviews.ToArray();
foreach (var source in SectionsContainer.Subviews.OfType<SectionViewBase>().Where(s=>s.ShouldStickSectionBelow))
{
var index = Array.IndexOf(subviews,source);
if(index == subviews.Length-1) continue;
var stickedView = subviews[index + 1];
var constraint = constraints.ToArray().FirstOrDefault(c => (c.View == source && c.SecondItem == stickedView) ||
(c.View == stickedView && c.SecondItem == source));
if (constraint != null)
{
constraint.Constant = 0;
}
}
SectionsContainer.AddConstraints(constraints);
}
public List<UIView> Content
{
get { return _content ?? (_content = new List<UIView>()); }
set { _content = value; }
}
public virtual void GetContent(List<UIView> content)
{
}
public CGSize ScrollableViewContentSize => SectionsContainer.ContentSize;
public void ScrollRectToVisible(CGRect rect)
{
UIView.BeginAnimations(null);
UIView.SetAnimationDuration(0.3);
var frame = SectionsContainer.ContentOffset;
frame.Y = rect.Y;
SectionsContainer.ContentOffset = frame;
UIView.CommitAnimations();
}
}
public interface IScrollableView
{
CGSize ScrollableViewContentSize { get; }
void ScrollRectToVisible(CGRect rect);
}
} |
namespace Sentry.DiagnosticSource.IntegrationTests;
public sealed class LocalDbFixture : IDisposable
{
public SqlInstance SqlInstance { get; }
public LocalDbFixture()
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
return;
}
SqlInstance = new(
name: "SqlListenerTests" + Namer.RuntimeAndVersion,
buildTemplate: TestDbBuilder.CreateTableAsync);
}
public void Dispose()
{
if (BuildServerDetector.Detected)
{
SqlInstance?.Cleanup();
}
}
}
|
using Pe.GyM.Security.Account.SRASecurityService;
using Pe.GyM.Security.Web.Session;
using Pe.Stracon.Politicas.Aplicacion.Core.Base;
using Pe.Stracon.Politicas.Aplicacion.Core.ServiceContract;
using Pe.Stracon.Politicas.Aplicacion.TransferObject.Request.General;
using Pe.Stracon.Politicas.Aplicacion.TransferObject.Response.General;
using Pe.Stracon.Politicas.Cross.Core.Base;
using Pe.Stracon.Politicas.Infraestructura.Core.Context;
using Pe.Stracon.Politicas.Presentacion.Core.Controllers.Base;
using Pe.Stracon.Politicas.Presentacion.Core.ViewModel.General.Trabajador;
using Pe.Stracon.Politicas.Presentacion.Recursos.Base;
using Pe.Stracon.Politicas.Presentacion.Recursos.Mensajes;
using Pe.Stracon.PoliticasCross.Core.Exception;
using Pe.Stracon.PoliticasCross.Core.Util;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace Pe.Stracon.Politicas.Presentacion.Core.Controllers.General
{
/// <summary>
/// Controladora de Unidad Operativa
/// </summary>
/// <remarks>
/// Creación: GMD 20150319
/// Modificación:
/// </remarks>
public class TrabajadorController : GenericController
{
#region Atributos
/// <summary>
/// Servicio de manejo de trabajadores.
/// </summary>
public ITrabajadorService trabajadorService { get; set; }
/// <summary>
/// Servicio de manejo de políticas.
/// </summary>
public IPoliticaService politicaService { get; set; }
/// <summary>
/// Servicio de manejo de unidad operativa
/// </summary>
public IUnidadOperativaService unidadOperativaService { get; set; }
/// <summary>
/// Interface para obtener el entorno de la aplicación.
/// </summary>
public IEntornoActualAplicacion entornoAplicacion { get; set; }
#endregion Atributos
#region Vistas
/// <summary>
/// Muestra la vista principal
/// </summary>
/// <returns>Vista principal de la opción</returns>
public ActionResult Index()
{
var identificacion = politicaService.ListarTipoDocumentoIdentidad();
TrabajadorModel modelo = new TrabajadorModel(identificacion.Result, true);
modelo.ControlPermisos = Utilitario.ObtenerControlPermisos(HttpGyMSessionContext.CurrentAccount(), "/General/Trabajador/");
return View(modelo);
}
#endregion Vistas
#region Vistas Parciales
/// <summary>
/// Muestra el formulario de datos
/// </summary>
/// <param name="CodigoTrabajador">Código de trabajador</param>
/// <returns>Vista FormularioTrabajador</returns>
public ActionResult FormularioTrabajador(string CodigoTrabajador)
{
TrabajadorModel modelo;
var identificacion = politicaService.ListarTipoDocumentoIdentidad();
if (!string.IsNullOrWhiteSpace(CodigoTrabajador))
{
var resultadoTrabajador = trabajadorService.BuscarTrabajador(new TrabajadorRequest()
{
CodigoTrabajador = new Guid(CodigoTrabajador)
});
var trabajador = resultadoTrabajador.Result.FirstOrDefault();
if (trabajador != null)
{
modelo = new TrabajadorModel(identificacion.Result, trabajador);
}
else
{
modelo = new TrabajadorModel(identificacion.Result, false);
}
}
else
{
modelo = new TrabajadorModel(identificacion.Result, false);
}
return PartialView(modelo);
}
/// <summary>
/// Muestra el formulario de trabajador unidad operativa
/// </summary>
/// <param name="codigoTrabajador">Código de trabajador</param>
/// <returns>Vista FormularioTrabajador</returns>
public ActionResult FormularioTrabajadorUnidadOperativa(string codigoTrabajador)
{
var unidadOperativaMatriz = unidadOperativaService.BuscarUnidadOperativa(new FiltroUnidadOperativa() { Nivel = DatosConstantes.Nivel.EmpresaMatriz }).Result;
var trabajador = trabajadorService.BuscarTrabajador(new TrabajadorRequest() { CodigoTrabajador = new Guid(codigoTrabajador) }).Result.First();
var modelo = new TrabajadorUnidadOperativaModel(trabajador, unidadOperativaMatriz);
return PartialView(modelo);
}
/// <summary>
/// Muestra el formulario de trabajador unidad operativa
/// </summary>
/// <param name="codigoTrabajador">Código de trabajador</param>
/// <returns>Vista FormularioTrabajador</returns>
public ActionResult FormularioTrabajadorSuplente(string codigoTrabajador)
{
var trabajadorSuplente = trabajadorService.BuscarTrabajadorSuplente(new TrabajadorRequest() { CodigoTrabajador = new Guid(codigoTrabajador) }).Result.FirstOrDefault();
var trabajador = trabajadorService.BuscarTrabajador(new TrabajadorRequest() { CodigoTrabajador = new Guid(codigoTrabajador) }).Result.FirstOrDefault();
TrabajadorSuplenteModel modelo = new TrabajadorSuplenteModel(trabajador);
if (trabajadorSuplente != null)
{
var trabajadorSuplenteDefinicion = trabajadorService.BuscarTrabajador(new TrabajadorRequest() { CodigoTrabajador = trabajadorSuplente.CodigoSuplente }).Result;
trabajadorSuplente.ListaSuplente = trabajadorSuplenteDefinicion.ToDictionary(x => x.CodigoTrabajador, y => y.NombreCompleto);
modelo = new TrabajadorSuplenteModel(trabajadorSuplente, trabajador);
}
return PartialView(modelo);
}
#endregion Vistas Parciales
#region Json
/// <summary>
/// Permite buscar el trabajador
/// </summary>
/// <param name="filtro">Filtro</param>
/// <returns>Retorna el trabajador</returns>
public JsonResult Buscar(TrabajadorRequest filtro)
{
var resultado = trabajadorService.BuscarTrabajador(filtro);
return Json(resultado);
}
/// <summary>
/// Permite buscar el trabajador
/// </summary>
/// <param name="filtro">Filtro de búsqueda</param>
/// <returns>Retorna el trabajador</returns>
public JsonResult BuscarTrabajadorUnidadOperativa(TrabajadorUnidadOperativaRequest filtro)
{
var resultado = trabajadorService.ListarTrabajadorUnidadOperativa(filtro);
return Json(resultado);
}
/// <summary>
/// Permite registrar el trabajador
/// </summary>
/// <param name="filtro">Filtro</param>
/// <returns>Resultado de la operación</returns>
public JsonResult Registrar(TrabajadorRequest filtro)
{
var resultado = trabajadorService.RegistrarTrabajador(filtro);
return Json(resultado);
}
/// <summary>
/// Permite registrar el trabajador
/// </summary>
/// <param name="filtro">Filtro</param>
/// <returns>Resultado de la operación</returns>
public JsonResult RegistrarTrabajadorUnidadOperativa(TrabajadorRequest filtro)
{
var resultado = trabajadorService.RegistrarTrabajadorUnidadOperativa(filtro);
return Json(resultado);
}
/// <summary>
/// Permite registrar el trabajador
/// </summary>
/// <param name="filtro">Filtro</param>
/// <returns>Resultado de la operación</returns>
public JsonResult RegistrarTrabajadorSuplente(TrabajadorSuplenteRequest filtro)
{
filtro.UsuarioSession = entornoAplicacion.UsuarioSession;
filtro.Terminal = entornoAplicacion.Terminal;
var resultado = trabajadorService.RegistrarTrabajadorSuplente(filtro);
return Json(resultado);
}
/// <summary>
/// Permite registrar validar
/// </summary>
/// <param name="filtro">Filtro</param>
/// <returns>Resultado de la operación</returns>
public JsonResult RegistrarValidar(TrabajadorRequest filtro)
{
var resultado = new ProcessResult<TrabajadorRequest>();
try
{
var validacion = trabajadorService.BuscarTrabajador(new TrabajadorRequest { CodigoIdentificacion = filtro.CodigoIdentificacion, Dominio = filtro.Dominio });
if (validacion.Result.Count > 0)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException<TrabajadorController>(UsuarioAD.EtiquetaTrabajadorExiste);
}
else
{
resultado = trabajadorService.RegistrarTrabajador(filtro);
}
}
catch (Exception e)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException<TrabajadorController>(e);
}
return Json(resultado);
}
/// <summary>
/// Permite cargar la firma del trabajador
/// </summary>
/// <returns>Resultado de la operación</returns>
public JsonResult CargarFirmaTrabajador()
{
var resultado = new ProcessResult<TrabajadorResponse>();
HttpPostedFileBase file = Request.Files.Count > 0 ? Request.Files[0] : null;
if (file.ContentLength > 0)
{
try
{
BinaryReader reader = new BinaryReader(file.InputStream);
byte[] firma = reader.ReadBytes((int)file.InputStream.Length);
var codigoTrabajador = new Guid(Request["CodigoTrabajador"].ToString());
Guid codigoFirma = Guid.Empty;
if(!string.IsNullOrWhiteSpace(Request["CodigoFirma"].ToString())){
codigoFirma = new Guid(Request["CodigoFirma"].ToString());
}
resultado = trabajadorService.RegistrarFirmaTrabajador(new TrabajadorRequest {
CodigoFirma = codigoFirma,
CodigoTrabajador = codigoTrabajador,
Firma = firma
});
}
catch (Exception)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException<TrabajadorController>(MensajeResource.ExistenciaRegistro);
}
}
else
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException<TrabajadorController>(MensajeResource.ExistenciaRegistro);
}
return Json(resultado);
}
/// <summary>
/// Permite ver la firma del trabajador
/// </summary>
/// <param name="codigoTrabajador">Código de Firma</param>
/// <returns>Retorna el trabajador con su firma</returns>
public JsonResult VerFirmaTrabajador(string codigoTrabajador)
{
var resultado = trabajadorService.BuscarFirmaTrabajador(new TrabajadorRequest() { CodigoTrabajador = new Guid(codigoTrabajador) });
return Json(resultado);
}
/// <summary>
/// Acción para la eliminación de trabajadores.
/// </summary>
/// <param name="listaTrabajadores">Lista de trabajadores</param>
/// <returns>Resultado de la operación</returns>
public JsonResult Eliminar(List<TrabajadorRequest> listaTrabajadores)
{
var resultado = trabajadorService.EliminarTrabajador(listaTrabajadores);
return Json(resultado);
}
/// <summary>
/// Elimina un proyecto asociado a un trabajador
/// </summary>
/// <param name="codigoTrabajadorUnidadOperativa">Código de trabajador unidad operativa</param>
/// <returns>Resultado del registro</returns>
public JsonResult EliminarTrabajadorUnidadOperativa(string codigoTrabajadorUnidadOperativa)
{
var resultado = trabajadorService.EliminarTrabajadorUnidadOperativa(new Guid(codigoTrabajadorUnidadOperativa));
return Json(resultado);
}
/// <summary>
/// Busca Trabajador
/// </summary>
/// <param name="filtroReq"></param>
/// <returns>Lista con el resultado de la operación</returns>
public JsonResult BuscarTrabajadorUO(string filtroReq)
{
TrabajadorRequest filtro = new TrabajadorRequest();
filtro.NombreCompleto = filtroReq;
ProcessResult<List<TrabajadorDatoMinimoResponse>> resultado = trabajadorService.BuscarTrabajadorDatoMinimo(filtro);
return Json(resultado.Result, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// Busca las Unidades Operativas de Nivel Proyecto
/// </summary>
/// <param name="filtro">Filtro de búsqueda</param>
/// <returns>Lista con el resultado de la operación</returns>
public JsonResult BuscarUnidadOperativaProyectoPorEmpresaMatriz(FiltroUnidadOperativa filtro)
{
ProcessResult<List<UnidadOperativaResponse>> resultado = unidadOperativaService.BuscarUnidadOperativaProyectoPorEmpresaMatriz(filtro);
return Json(resultado, JsonRequestBehavior.AllowGet);
}
#endregion Json
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace GanzenBord_Database
{
public class Bord
{
public int positie;
public string Message { get; set; }
public int PositieChecken(int werp, int huidige_positie)
{
if (huidige_positie == 23)
{
Message = $"Je hebt { werp} gegooid, je staat op plaats {huidige_positie}. Het spel is over.";
positie = 2000;
}
else if (huidige_positie == 25 || huidige_positie == 45)
{
Message = $"Je hebt { werp} gegooid, je staat op plaats {huidige_positie}. Je moet terug naar de start.";
positie = 0;
}
else if (huidige_positie == 10 || huidige_positie == 20 || huidige_positie == 30 || huidige_positie == 40 || huidige_positie == 50 || huidige_positie == 60)
{
positie = huidige_positie + werp;
Message = $"Je hebt { werp} gegooid, je staat op plaats {huidige_positie}. Bonus stapjes! Je staat op plaats {positie}";
}
else
{
positie = huidige_positie;
Message = $"Je hebt { werp} gegooid, je staat op plaats {huidige_positie}. Gooi je dobbelsteen (g)";
}
return positie;
}
}
}
|
using Microsoft.AspNetCore.Mvc;
using System.Linq;
using System.Threading.Tasks;
using TestGr4d3.BOL;
using TestGr4d3.DAL.IRepositorio;
using TestGr4d3.UI.ViewModels;
using TestGr4d3.UI.ViewModels.EstudianteVM;
namespace TestGr4d3.UI.Controllers
{
public class EstudianteController : Controller
{
private readonly IEstudianteRepo _repo;
public EstudianteController(IEstudianteRepo repo) => _repo = repo;
[HttpGet]
public async Task<IActionResult> Index()
{
var estudiantes = await _repo.ObtenerTodos();
var modelo = estudiantes.Select(x => new EstudianteIndexVM()
{
Id = x.Id,
NombreCompleto = x.Nombre + " " + x.Apellido,
ImagenURL = x.ImagenURL,
Curso = x.Curso,
});
return View(modelo);
}
[HttpGet]
public IActionResult Agregar() => View();
[HttpPost]
public async Task<IActionResult> Agregar(EstudianteFormularioVM estudianteFormulario)
{
if (ModelState.IsValid)
{
var estudiante = new Estudiante()
{
Nombre = estudianteFormulario.Nombre,
Apellido = estudianteFormulario.Apellido,
Curso = estudianteFormulario.Curso,
Edad = estudianteFormulario.Edad,
ImagenURL = estudianteFormulario.ImagenURL
};
await _repo.Agregar(estudiante);
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> Actualizar(int id)
{
var estudiante = await _repo.Obtener(id);
var estudianteModel = new EstudianteFormularioVM()
{
Id = estudiante.Id,
Nombre = estudiante.Nombre,
Apellido = estudiante.Apellido,
Curso = estudiante.Curso,
Edad = estudiante.Edad,
ImagenURL = estudiante.ImagenURL
};
return View(estudianteModel);
}
[HttpPost]
public async Task<IActionResult> Actualizar(EstudianteFormularioVM estudianteFormulario)
{
if (ModelState.IsValid)
{
var estudiante = new Estudiante()
{
Id = estudianteFormulario.Id,
Nombre = estudianteFormulario.Nombre,
Apellido = estudianteFormulario.Apellido,
Curso = estudianteFormulario.Curso,
Edad = estudianteFormulario.Edad,
ImagenURL = estudianteFormulario.ImagenURL
};
await _repo.Actualizar(estudiante);
return RedirectToAction("Index");
}
return View();
}
[HttpGet]
public async Task<IActionResult> Detalles(int id)
{
var estudiante = await _repo.Obtener(id);
var estudianteVMDetalles = new EstudianteVMDetalles()
{
Id = estudiante.Id,
Nombre = estudiante.Nombre,
Apellido = estudiante.Apellido,
Curso = estudiante.Curso,
Edad = estudiante.Edad,
ImagenURL = estudiante.ImagenURL,
FechaIngreso = estudiante.FechaIngreso
};
return View(estudianteVMDetalles);
}
[HttpGet]
public async Task<IActionResult> Eliminar(int id)
{
try
{
await _repo.Eliminar(id);
return RedirectToAction("Index");
}
catch
{
TempData["ErrorEstudiante"] =
"Este estudiante está vinculado con un examen. Desvincúlelo para eliminarlo.";
return RedirectToAction("Index");
}
}
}
} |
using System.Collections;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
public class ToColor : MonoBehaviour
{
public GameObject cube;
public bool estSelectionnable;
public bool estSelectionne;
public EnZoneDepot depot;
// Start is called before the first frame update
void Start()
{
To_Color(Color.black);
}
// Update is called once per frame
void Update()
{
if(depot.estEnZoneDepot) To_Color(Color.green);
else if (estSelectionnable) To_Color(Color.yellow);
else if (estSelectionne) To_Color(Color.blue);
else To_Color(Color.black);
}
void To_Color(Color color)
{
cube.GetComponent<Renderer>().material.color = color;
}
}
|
using System;
namespace DM7_PPLUS_Integration.Daten
{
public readonly struct Dienstbuchung
{
public readonly Guid MitarbeiterId;
public readonly int DienstId;
public readonly Uhrzeit Beginnt_um;
public Dienstbuchung(Guid mitarbeiterId, int dienstId, Uhrzeit beginntUm)
{
MitarbeiterId = mitarbeiterId;
DienstId = dienstId;
Beginnt_um = beginntUm;
}
}
} |
using System;
using System.Collections;
using UnityEngine;
public class Enemy : MonoBehaviour
{
[SerializeField] private float damage = 0;
public float EnemyDamage;
private Transform player;
private Transform playerCollider1;
private Transform playerCollider2;
private Animator animator;
[SerializeField] private float speed = 0;
[SerializeField] private float stoppingDistance = 0;
[SerializeField] private float sight = 0;
[SerializeField] private float enemyHealth = 0;
private bool canDo = true;
private bool Attacked;
private bool moveBack;
private bool moveForward;
[SerializeField] private bool slime;
[SerializeField] private bool wolf;
private float enemyNumber = 0;
private void Start()
{
player = GameObject.FindWithTag("Player").transform;
playerCollider1 = player.Find("MCCollider1").GetComponent<Transform>();
playerCollider2 = player.Find("MCCollider2").GetComponent<Transform>();
animator = this.GetComponent<Animator>();
if (slime) enemyNumber = 1;
else if (wolf) enemyNumber = 2;
animator.SetFloat("Enemy", enemyNumber);
}
private void FixedUpdate()
{
if (canDo)
{
if (Vector2.Distance(transform.position, playerCollider1.position) < sight || Vector2.Distance(transform.position, playerCollider2.position) < sight)
{
animator.SetBool("Idle", false);
if (Vector2.Distance(transform.position, playerCollider1.position) > stoppingDistance && Vector2.Distance(transform.position, playerCollider2.position) > stoppingDistance)
{
transform.position = Vector3.MoveTowards(transform.position, player.transform.position, speed);
}
else
{
Attack();
}
}
else
{
animator.SetBool("Idle", true);
}
}
if (Attacked)
{
if (moveBack)
{
transform.position = Vector3.MoveTowards(transform.position, player.transform.position, -0.07f);
}
if (moveForward)
{
transform.position = Vector3.MoveTowards(transform.position, player.transform.position, 0.07f);
}
}
}
public void HitEnemy(float damage)
{
enemyHealth -= damage;
Attacked = true;
IEnumerator coroutine = constatlyMoveBackAndStay();
StartCoroutine(coroutine);
if (enemyHealth < 1)
{
Destroy(gameObject);
}
}
private void Update()
{
animator.SetFloat("HorizontalSpeed", (player.position.x - transform.position.x));
}
private void Attack()
{
canDo = false;
IEnumerator coroutine = waitForAttackAnimation();
StartCoroutine(coroutine);
attackAnimation();
Attacked = true;
HealthBar.SetHealth(damage);
}
private IEnumerator waitForAttackAnimation()
{
yield return new WaitForSeconds(0.75f);
canDo = true;
}
private void attackAnimation()
{
IEnumerator coroutine = constatlyMoveBack();
StartCoroutine(coroutine);
}
private IEnumerator constatlyMoveBack()
{
moveForward = false;
moveBack = true;
yield return new WaitForSeconds(0.08f);
IEnumerator coroutine = constatlyMoveForward();
StartCoroutine(coroutine);
}
private IEnumerator constatlyMoveForward()
{
moveBack = false;
moveForward = true;
yield return new WaitForSeconds(0.08f);
Attacked = false;
}
private IEnumerator constatlyMoveBackAndStay()
{
moveForward = false;
moveBack = true;
yield return new WaitForSeconds(0.12f);
Attacked = false;
}
}
|
using System.Linq;
using LevelGenerator.Scripts.Helpers;
using UnityEngine;
namespace LevelGenerator.Scripts
{
public class Section : MonoBehaviour
{
/// <summary>
/// Section tags
/// </summary>
public string[] Tags;
/// <summary>
/// Tags that this section can annex
/// </summary>
public string[] CreatesTags;
/// <summary>
/// Exits node in hierarchy
/// </summary>
public Exits Exits;
/// <summary>
/// Bounds node in hierarchy
/// </summary>
public Bounds Bounds;
public bool ForceCreate;
public bool ForceDeadEnd;
/// <summary>
/// Chances of the section spawning a dead end
/// </summary>
public int DeadEndChance;
protected LevelGenerator LevelGenerator;
protected int order;
public void Initialize(LevelGenerator levelGenerator, int sourceOrder)
{
LevelGenerator = levelGenerator;
transform.SetParent(LevelGenerator.Container);
LevelGenerator.RegisterNewSection(this);
order = sourceOrder + 1;
GenerateAnnexes();
}
protected void GenerateAnnexes()
{
if (CreatesTags.Any() || ForceDeadEnd )
{
foreach (var e in Exits.ExitSpots)
{
if ((LevelGenerator.LevelSize > 0 && (order < LevelGenerator.MaxAllowedOrder)) || ForceCreate || ForceDeadEnd)
{
if (ForceCreate)
{
GenerateSection(e);
}
else if (ForceDeadEnd)
{
PlaceDeadEnd(e);
}
else
{
if (RandomService.RollD100(DeadEndChance))
{
PlaceDeadEnd(e);
}
else
{
GenerateSection(e);
}
}
}
else
{
PlaceDeadEnd(e);
}
}
}
}
protected void GenerateSection(Transform exit)
{
var candidate = IsAdvancedExit(exit)
? BuildSectionFromExit(exit.GetComponent<AdvancedExit>())
: BuildSectionFromExit(exit);
if (LevelGenerator.IsSectionValid(candidate.Bounds, Bounds))
{
candidate.Initialize(LevelGenerator, order);
}
else
{
Destroy(candidate.gameObject);
PlaceDeadEnd(exit);
}
}
protected void PlaceDeadEnd(Transform exit) => Instantiate(LevelGenerator.DeadEnds.PickOne(), exit).Initialize(LevelGenerator);
protected bool IsAdvancedExit(Transform exit) => exit.GetComponent<AdvancedExit>() != null;
protected Section BuildSectionFromExit(Transform exit) => Instantiate(LevelGenerator.PickSectionWithTag(CreatesTags), exit).GetComponent<Section>();
protected Section BuildSectionFromExit(AdvancedExit exit) => Instantiate(LevelGenerator.PickSectionWithTag(exit.CreatesTags), exit.transform).GetComponent<Section>();
}
} |
namespace MvcApp.Web.Services
{
using System.Linq;
using BindingModels;
using Data;
using Data.Models;
using SimpleHttpServer.Models;
public class LoginServices : Service
{
public LoginServices(UnitOfWork unit)
: base(unit)
{
}
public bool IsLoginViewModelValid(LoginBindingModel model)
{
var cre = model.Username;
var pass = model.Password;
return this.unit.Users.All()
.Any(u => u.Username == cre && u.Password == pass);
}
public User GetUserOfLoginBind(LoginBindingModel model)
{
User currentUser =
this.unit.Users.All()
.First(u => u.Password == model.Password &&
u.Username == model.Username);
return currentUser;
}
public void LoginUser(User user, HttpSession session)
{
var sessionEntity = new Login()
{
LoginId = session.Id,
IsActive = true,
UserId = user.Id
};
this.unit.Sessions.Add(sessionEntity);
this.unit.Sessions.SaveChanges();
}
}
} |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using JustRipeFarm.ClassEntity;
namespace JustRipeFarm
{
public partial class FormStoreroom : Form
{
public string state = "";
public Storeroom sr1;
public FormStoreroom()
{
InitializeComponent();
}
private void btnDone_Click(object sender, EventArgs e)
{
if (state == "Edit")
{
updateStock();
}
else
{
if (String.IsNullOrEmpty(descriptionText.Text))
{
if (String.IsNullOrEmpty(storeNumericUpDown.Text))
{
if (String.IsNullOrEmpty(tempText.Text))
{
MessageBox.Show("Please fill up the box");
}
MessageBox.Show("Please fill up the box");
}
MessageBox.Show("Please fill up the box");
}
else
{
addStock();
}
}
}
public void addStock()
{
Storeroom store = new Storeroom();
store.Description = descriptionText.Text;
store.StoringQty = Convert.ToInt32(storeNumericUpDown.Value);
store.Temperature = Int32.Parse(tempText.Text);
bool avail = false;
int availability = availabilityBox.SelectedIndex;
if (availability == 1)
{
avail = true;
}
store.Availability = avail;
InsertSQL storeHnd = new InsertSQL();
int addrecord = storeHnd.addNewStore(store);
MessageBox.Show(addrecord + " Your record is added");
}
public void updateStock()
{
Storeroom store = new Storeroom();
store.Id = sr1.Id;
store.Description = descriptionText.Text;
store.StoringQty = Convert.ToInt32(storeNumericUpDown.Value);
store.Temperature = Int32.Parse(tempText.Text);
bool avail = false;
int availability = availabilityBox.SelectedIndex;
if (availability == 1)
{
avail = true;
}
store.Availability = avail;
UpdateSQL storeHnd = new UpdateSQL();
storeHnd.updateStore(store);
MessageBox.Show(" Your record is added");
}
private void btnCancel_Click(object sender, EventArgs e)
{
this.Close();
}
private void availabilityBox_SelectedIndexChanged(object sender, EventArgs e)
{
}
private void FormStoreroom_Load(object sender, EventArgs e)
{
InsertSQL storeroom = new InsertSQL();
if (state == "Edit")
{
descriptionText.Text = sr1.Description;
storeNumericUpDown.Text = sr1.StoringQty.ToString();
tempText.Text = sr1.Temperature.ToString();
}
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace Knjizara.Models
{
public class NarudzbenicaViewModel
{
public int NarudzbenicaID { get; set; }
public DateTime Datum { get; set; }
public float UkupnaCena { get; set; }
public string Zaposleni { get; set; }
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using Capa_de_Negocios_ONG_SYS;
using System.Data;
namespace ONG_SYS
{
/// <summary>
/// Lógica de interacción para FRM_Administracion_Clientes.xaml
/// </summary>
public partial class FRM_Administracion_Clientes : Window
{
private int idCliente = 0;
CN_Clientes objetoCN = new CN_Clientes();
public FRM_Administracion_Clientes()
{
InitializeComponent();
}
private void btn_Regresar_P_Click(object sender, RoutedEventArgs e)
{
this.Hide();
FRM_Principal_Cliente paginaanteriorP = new FRM_Principal_Cliente();
paginaanteriorP.ShowDialog();
this.Close();
}
private void dgvCLIENTES_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
DataRowView rowView = dgvCLIENTES.SelectedItem as DataRowView;
if (dgvCLIENTES.SelectedItem != null)
{
}
if (rowView != null)
{
idCliente = Convert.ToInt32(rowView[0].ToString());
TXT_Nombre_Cliente.Text = rowView[1].ToString().Split(' ')[0];
TXT_APELLIDO_C.Text = rowView[1].ToString().Split(' ')[1];
if (rowView[2].ToString().Length == 10)
{
cmb_TipoCliente.SelectedIndex = 0;
}
else
{
cmb_TipoCliente.SelectedIndex = 1;
}
TXT_IDENTIFICACION_C.Text = rowView[2].ToString();
TXT_Telefono.Text = rowView[3].ToString();
TXT_direccion_C.Text = rowView[4].ToString();
TXT_Correo.Text = rowView[5].ToString();
btn_ACTUALIZAR_S.IsEnabled = true;
btn_ELIMINAR_P.IsEnabled = true;
btn_Regresar_P.IsEnabled = true;
TXT_IDENTIFICACION_C.IsEnabled = false;
TXT_Nombre_Cliente.IsEnabled = false;
TXT_APELLIDO_C.IsEnabled = false;
cmb_TipoCliente.IsEnabled = false;
TXT_direccion_C.IsEnabled = true;
TXT_Telefono.IsEnabled = true;
TXT_Correo.IsEnabled = true;
}
else
{
btn_ACTUALIZAR_S.IsEnabled = false;
btn_ELIMINAR_P.IsEnabled = false;
btn_Regresar_P.IsEnabled = true;
TXT_IDENTIFICACION_C.IsEnabled = false;
TXT_Nombre_Cliente.IsEnabled = false;
TXT_APELLIDO_C.IsEnabled = false;
cmb_TipoCliente.IsEnabled = false;
TXT_direccion_C.IsEnabled = false;
TXT_Telefono.IsEnabled = false;
TXT_Correo.IsEnabled = false;
}
}
private void MostrarCliente()
{
CN_Clientes objec = new CN_Clientes();
dgvCLIENTES.SetBinding(ItemsControl.ItemsSourceProperty, new Binding { Source = objec.MostrarTipoProducto() });
}
private void dgvCLIENTES_Loaded(object sender, RoutedEventArgs e)
{
//MostrarCliente();
}
private void limpiarForm()
{
TXT_IDENTIFICACION_C.Clear();
TXT_Nombre_Cliente.Clear();
TXT_APELLIDO_C.Clear();
cmb_TipoCliente.Text = "";
TXT_direccion_C.Clear();
TXT_Telefono.Clear();
TXT_Correo.Clear();
}
private void btn_ELIMINAR_C_Click(object sender, RoutedEventArgs e)
{
if (dgvCLIENTES.SelectedItem == null)
{
MessageBox.Show("Verifique si se selecciono algún campo");
}
else
{
objetoCN.EliminarCliente(idCliente);
MessageBox.Show("Se ha eliminado correctamente");
//MostrarCliente();
limpiarForm();
}
}
private void TXT_BUSCAR_CLIENTE_TextChanged(object sender, TextChangedEventArgs e)
{
//CN_Clientes objetoCN = new CN_Clientes();
//dgvCLIENTES.SetBinding(ItemsControl.ItemsSourceProperty, new Binding { Source = objetoCN.BuscarC(TXT_BUSCAR_CLIENTE.Text) });
}
private void btn_ACTUALIZAR_S_Click(object sender, RoutedEventArgs e)
{
string identificacion = TXT_IDENTIFICACION_C.Text;
if (cmb_TipoCliente.SelectedIndex == 0)
{
identificacion = identificacion + "001";
}
if (VERIFICA_IDENTIFICACION.VerificaIdentificacion(identificacion) == false || identificacion.Length < 13)
{
MessageBox.Show("Verifique identificación del cliente");
return;
}
else if (string.IsNullOrEmpty(TXT_Nombre_Cliente.Text))
{
MessageBox.Show("Verifique que el campo Nombre del cliente se encuentre lleno");
return;
}
else if (string.IsNullOrEmpty(TXT_IDENTIFICACION_C.Text))
{
MessageBox.Show("Verifique que el campo de identificación se encuentre lleno");
return;
}
else if (cmb_TipoCliente.SelectedIndex == -1)
{
MessageBox.Show("Seleccione el tipo de cliente");
return;
}
else if (string.IsNullOrEmpty(TXT_APELLIDO_C.Text))
{
MessageBox.Show("Verifique que el campo apellido se encuentre lleno");
return;
}
else if (string.IsNullOrEmpty(TXT_direccion_C.Text))
{
MessageBox.Show("Verifique que el campo Dirección se encuentre lleno");
return;
}
else if (string.IsNullOrEmpty(TXT_direccion_C.Text))
{
MessageBox.Show("Verifique que el campo Teléfono se encuentre lleno");
return;
}
else if (string.IsNullOrEmpty(TXT_Correo.Text))
{
MessageBox.Show("Verifique que el campo de correo electrónico se encuentre lleno");
return;
}
else if (VERIFICA_IDENTIFICACION.VerificaIdentificacion(identificacion) == true)
{
try
{
objetoCN.EditarCliente(idCliente, cmb_TipoCliente.SelectedIndex + 1, TXT_Nombre_Cliente.Text, TXT_APELLIDO_C.Text, TXT_IDENTIFICACION_C.Text, TXT_Telefono.Text, TXT_direccion_C.Text, TXT_Correo.Text);
MessageBox.Show("Cliente actualizado correctamente!","",MessageBoxButton.OK, MessageBoxImage.Exclamation);
limpiarForm();
}
catch (Exception ex)
{
MessageBox.Show("Error Producido por: " + ex);
}
}
}
private void cmb_TipoCliente_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
TXT_IDENTIFICACION_C.Clear();
if (((ComboBox)sender).SelectedIndex == 0)
{
TXT_IDENTIFICACION_C.MaxLength = 10;
}
else
{
TXT_IDENTIFICACION_C.MaxLength = 13;
}
}
private void BTN_BuscarProducto_Click(object sender, RoutedEventArgs e)
{
CN_Clientes objetoCN = new CN_Clientes();
dgvCLIENTES.SetBinding(ItemsControl.ItemsSourceProperty, new Binding { Source = objetoCN.BuscarC(TXT_BUSCAR_CLIENTE.Text) });
}
private void btn_ELIMINAR_P_Click(object sender, RoutedEventArgs e)
{
if (dgvCLIENTES.SelectedItem == null)
{
MessageBox.Show("Verifique si se selecciono algún campo");
}
else
{
try
{
objetoCN.EliminarCliente(idCliente);
MessageBox.Show("Se ha eliminado correctamente");
dgvCLIENTES.SetBinding(ItemsControl.ItemsSourceProperty, new Binding { Source = new DataTable() });
limpiarForm();
}
catch (Exception ex)
{
MessageBox.Show("No se puede eliminar al cliente porque tiene facturas a su nombre");
}
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
TXT_IDENTIFICACION_C.IsEnabled=false;
TXT_Nombre_Cliente.IsEnabled = false;
TXT_APELLIDO_C.IsEnabled = false;
cmb_TipoCliente.IsEnabled = false;
TXT_direccion_C.IsEnabled = false;
TXT_Telefono.IsEnabled = false;
TXT_Correo.IsEnabled = false;
}
private void TXT_BUSCAR_CLIENTE_LostFocus(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(TXT_BUSCAR_CLIENTE.Text)) {
TXT_BUSCAR_CLIENTE.Visibility = System.Windows.Visibility.Collapsed;
Waterfall_buscar_c.Visibility = System.Windows.Visibility.Visible;
}
}
private void Waterfall_buscar_c_GotFocus(object sender, RoutedEventArgs e)
{
Waterfall_buscar_c.Visibility = System.Windows.Visibility.Collapsed;
TXT_BUSCAR_CLIENTE.Visibility = System.Windows.Visibility.Visible;
TXT_BUSCAR_CLIENTE.Focus();
}
}
}
|
using System.Collections;
using System;
using System.Collections.Generic;
using UnityEngine;
public class Node : IHeapItem<Node>
{
public bool m_Walkable; // 歩行可能か
public Vector3 m_WorldPosition; // ワールド座標
public int m_gridX; // グリッドNo（X座標）
public int m_gridY; // グリッドNo（Y座標）
public int gCost; // ノード間のコスト
public int hCost; // ヒューリスティックコスト
public Node parent; // 親ノード
int heapIndex;
public Node(bool walkble, Vector3 worldPosition, int gridX, int gridY)
{
m_Walkable = walkble;
m_WorldPosition = worldPosition;
m_gridX = gridX;
m_gridY = gridY;
}
// トータル（最短）コストを取得
public int fCost
{
get
{
return gCost + hCost;
}
}
public int HeapIndex
{
get
{
return heapIndex;
}
set
{
heapIndex = value;
}
}
// コストを比較する関数
public int CompareTo(Node nodeToCompare)
{
int compare = fCost.CompareTo(nodeToCompare.fCost);
if(compare == 0)
{
compare = hCost.CompareTo(nodeToCompare.hCost);
}
return -compare;
}
}
|
//Google Calendar related namespaces
using Google.Apis.Auth.OAuth2;
using Google.Apis.Calendar.v3;
using Google.Apis.Calendar.v3.Data;
using Google.Apis.Services;
using Google.Apis.Util.Store;
//using Google.Apis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Threading; //This is used in the voice to text application
using System.Windows.Forms;
namespace GoogleVoice
{
class deleteEvent
{
public CalendarService service;
public void login()
{
string[] Scopes = { CalendarService.Scope.Calendar };
string ApplicationName = "Google Calendar API .NET Quickstart";
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/calendar-dotnet-quickstart.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
//synthesizer.SpeakAsync("Credential file saved to: " + credPath);
//richTextBox1.Text = "Credential file saved to: " + credPath;
}
// Create Google Calendar API service.
service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
}
public void deleteAnEvent()
{
//I referenced Google Developer and Linda Lawton for this:
//https://github.com/LindaLawton/Google-Dotnet-Samples/blob/master/Google-Calendar/Google-Calendar-Api-dotnet/Google-Clndr-Api-dotnet/Google-Clndr-Api-dotnet/DaimtoEventHelper.cs
// Initialize Calendar service with valid OAuth credentials
//Calendar service = new Calendar.Builder(httpTransport, jsonFactory, credentials)
// .setApplicationName("applicationName").build();
// Delete an event
//service.Events.Delete("primary", "Google I/O 2015").deleteAnEvent.execute;
//service.events().delete('primary', "eventId").execute();
//I will reference this kind soul in the future:
//https://groups.google.com/forum/#!topic/google-calendar-api/gZO18rvvqHM
//try
//{
// return service.Events.Delete('primary', 'Google I/O 2015').Execute();
//}
//catch (Exception ex)
//{
//Console.WriteLine(ex.Message);
//return null;
//}
}
}
} |
using MikeGrayCodes.BuildingBlocks.Domain.Events;
using System.Collections.Generic;
namespace MikeGrayCodes.BuildingBlocks.Infrastructure.DomainEventsDispatching
{
public interface IDomainEventsAccessor
{
List<IDomainEvent> GetAllDomainEvents();
void ClearAllDomainEvents();
}
} |
using EQS.AccessControl.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
namespace EQS.AccessControl.Repository.Configurations
{
class PersonConfiguration : IEntityTypeConfiguration<Person>
{
public void Configure(EntityTypeBuilder<Person> builder)
{
builder.ToTable("People");
builder.HasKey(h => h.Id);
builder.HasIndex(u => u.Id).IsUnique();
builder.HasOne(h => h.Credential).WithOne(o => o.Person).HasForeignKey<Credential>(f => f.Id);
builder.Property(p => p.Name).IsRequired();
builder.Ignore(i => i.Validations);
}
}
}
|
using System;
using Ludotek.Api.Dto;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
namespace Ludotek.Api
{
public partial class Context : DbContext
{
public virtual DbSet<LudoTagDto> LudoTag { get; set; }
public virtual DbSet<LudothequeDto> Ludotheque { get; set; }
public virtual DbSet<TagDto> Tag { get; set; }
public Context(DbContextOptions<Context> options) : base(options) { }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<LudoTagDto>(entity =>
{
entity.HasKey(e => new { e.LudothequeId, e.TagId });
entity.HasOne(d => d.Ludotheque)
.WithMany(p => p.LudoTag)
.HasForeignKey(d => d.LudothequeId)
.OnDelete(DeleteBehavior.ClientSetNull)
.HasConstraintName("FK_LudoTag_Ludotheque");
entity.HasOne(d => d.Tag)
.WithMany(p => p.LudoTag)
.HasForeignKey(d => d.TagId)
.OnDelete(DeleteBehavior.ClientSetNull)
.HasConstraintName("FK_LudoTag_Tag");
});
modelBuilder.Entity<LudothequeDto>(entity =>
{
entity.Property(e => e.NomItem)
.IsRequired()
.HasMaxLength(255);
});
modelBuilder.Entity<TagDto>(entity =>
{
entity.Property(e => e.NomTag)
.IsRequired()
.HasMaxLength(50);
});
}
}
}
|
using System;
namespace BlazorShared.Models.Schedule
{
public class GetByIdScheduleResponse : BaseResponse
{
public ScheduleDto Schedule { get; set; } = new ScheduleDto();
public GetByIdScheduleResponse(Guid correlationId) : base(correlationId)
{
}
public GetByIdScheduleResponse()
{
}
}
}
|
/* Copyright 2019-2020 Sannel Software, L.L.C.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.*/
using Sannel.House.Base.Sensor;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text;
using System.Text.Json;
namespace Sannel.House.SensorLogging.Models
{
public class SensorEntry
{
public SensorEntry()
{
Values = new Collection<SensorReading>();
}
/// <summary>
/// Gets or sets the sensor entry identifier.
/// </summary>
/// <value>
/// The sensor entry identifier.
/// </value>
[Key]
public Guid SensorEntryId { get; set; }
/// <summary>
/// Gets or sets the local device identifier.
/// </summary>
/// <value>
/// The local device identifier.
/// </value>
[Required]
public Guid LocalDeviceId { get; set; }
/// <summary>
/// Gets or sets the type of the sensor.
/// </summary>
/// <value>
/// The type of the sensor.
/// </value>
[Required]
public SensorTypes SensorType { get; set; }
/// <summary>
/// Gets or sets the creation date.
/// </summary>
/// <value>
/// The creation date.
/// </value>
public DateTimeOffset CreationDate { get; set; }
/// <summary>
/// Gets or sets the values.
/// </summary>
/// <value>
/// The values.
/// </value>
public Collection<SensorReading> Values { get; set; }
/// <summary>
/// Converts to string.
/// </summary>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public override string ToString()
=> $@"SensorEntryId={SensorEntryId}
LocalDeviceId={LocalDeviceId}
SensorType={SensorType}
CreationDate={CreationDate}
Values={JsonSerializer.Serialize(Values)}
";
}
}
|
using System.ComponentModel;
using Xamarin.Forms;
using XF40Demo.Services;
namespace XF40Demo.ViewModels
{
public abstract class BaseViewModel : INotifyPropertyChanged
{
protected readonly SettingsService settings = SettingsService.Instance();
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propertyName)
{
var changed = PropertyChanged;
if (changed != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
public void OnAppearing()
{
RefreshView();
MessagingCenter.Subscribe<App>(this, "AppOnResume", (_) => RefreshView());
}
public virtual void OnDisappearing()
{
MessagingCenter.Unsubscribe<App>(this, "AppOnResume");
}
protected abstract void RefreshView();
}
}
|
namespace SubC.Attachments {
using UnityEngine;
using System.Collections.Generic;
public abstract class OneToOneAttachStrategy : AttachStrategy {
public enum Categories {
Object1, Object2
}
AttachCategoryDefinition[] categories;
public override AttachCategoryDefinition[] GetCategories() {
if (categories == null) {
categories = new AttachCategoryDefinition[] {
new AttachCategoryDefinition(GetLabelForObject1(), GetLabelForObject1(), 1, 1),
new AttachCategoryDefinition(GetLabelForObject2(), GetLabelForObject2(), 1, 1)
};
}
return categories;
}
public virtual string GetLabelForObject1() {
return "Object1";
}
public virtual string GetLabelForObject2() {
return "Object2";
}
protected enum Providers {
Object1, Object2
}
public override string GetLabelForProvider(int provider) {
if (provider == (int) Providers.Object1)
return GetLabelForObject1();
return GetLabelForObject2();
}
public override int[] GetProvidersForTransitioner(int category) {
if (category == (int) Categories.Object1)
return new int[] { (int) Providers.Object1, (int) Providers.Object2 };
else
return new int[] { (int) Providers.Object2, (int) Providers.Object1 };
}
public override AttachObject ResolveProvider(int provider, AttachObject reference) {
return ResolveProvider(provider, reference.attachment);
}
public override AttachObject ResolveProvider(int provider, Attachment attachment) {
if (provider == (int) Providers.Object1)
return GetObject1(attachment);
return GetObject2(attachment);
}
public AttachObject GetObject1(Attachment attachment) {
return attachment.objects.Get((int) Categories.Object1, 0);
}
public AttachObject GetObject2(Attachment attachment) {
return attachment.objects.Get((int) Categories.Object2, 0);
}
protected abstract void ConnectBoth(AttachObject obj1, AttachObject obj2);
protected abstract void DisconnectBoth(AttachObject obj1, AttachObject obj2);
public override bool ConnectObject(AttachObject obj) {
if (obj.category == (int) Categories.Object1) {
AttachObject obj2 = GetObject2(obj.attachment);
if (obj2 != null && obj2.isConnected)
ConnectBoth(obj, obj2);
} else {
AttachObject obj1 = GetObject1(obj.attachment);
if (obj1 != null && obj1.isConnected)
ConnectBoth(obj1, obj);
}
return true;
}
public override void DisconnectObjectImmediate(AttachObject obj) {
// keep in mind obj may be orphaned at this point
if (obj.category == (int) Categories.Object1) {
AttachObject obj2 = GetObject2(obj.attachment);
if (obj2 != null && obj2.isConnected)
DisconnectBoth(obj, obj2);
} else {
AttachObject obj1 = GetObject1(obj.attachment);
if (obj1 != null && obj1.isConnected)
DisconnectBoth(obj1, obj);
}
}
protected bool IsConnected(Attachment attachment) {
AttachObject obj1 = GetObject1(attachment);
AttachObject obj2 = GetObject2(attachment);
return obj1 != null && obj1.isConnected && obj2 != null && obj2.isConnected;
}
}
} |
using System.Collections.Generic;
using Xunit.Sdk;
namespace FluentTest
{
public interface IScenario
{
IEnumerable<ITestCommand> CreateTestCommands(IMethodInfo method);
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DFC.ServiceTaxonomy.GraphSync.Models;
using DFC.ServiceTaxonomy.JobProfiles.DataTransfer.Extensions;
using DFC.ServiceTaxonomy.JobProfiles.DataTransfer.Models.ServiceBus;
using DFC.ServiceTaxonomy.JobProfiles.DataTransfer.ServiceBus.Interfaces;
using DFC.ServiceTaxonomy.PageLocation.Models;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using OrchardCore.ContentManagement;
using OrchardCore.Sitemaps.Models;
using OrchardCore.Title.Models;
namespace DFC.ServiceTaxonomy.JobProfiles.DataTransfer.ServiceBus.Converters
{
internal class JobProfileMessageConverter : IMessageConverter<JobProfileMessage>
{
private readonly IServiceProvider _serviceProvider;
private readonly IMessageConverter<HowToBecomeData> _howToBecomeMessageConverter;
private readonly IMessageConverter<WhatYouWillDoData> _whatYouWillDoDataMessageConverter;
private readonly IMessageConverter<WhatItTakesData> _whatItTakesMessageConverter;
private readonly IMessageConverter<SocCodeItem> _socCodeMessageConverter;
private readonly ILogger<JobProfileMessageConverter> _logger;
public JobProfileMessageConverter(
IMessageConverter<HowToBecomeData> howToBecomeMessageConverter,
IMessageConverter<WhatYouWillDoData> whatYouWillDoDataMessageConverter,
IMessageConverter<WhatItTakesData> whatItTakesMessageConverter,
IMessageConverter<SocCodeItem> socCodeMessageConverter,
ILogger<JobProfileMessageConverter> logger,
IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_howToBecomeMessageConverter = howToBecomeMessageConverter;
_whatYouWillDoDataMessageConverter = whatYouWillDoDataMessageConverter;
_whatItTakesMessageConverter = whatItTakesMessageConverter;
_socCodeMessageConverter = socCodeMessageConverter;
_logger = logger;
}
public async Task<JobProfileMessage> ConvertFromAsync(ContentItem contentItem)
{
try
{
var contentManager = _serviceProvider.GetRequiredService<IContentManager>();
IEnumerable<ContentItem> relatedCareersProfiles = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.Relatedcareerprofiles, contentManager);
IEnumerable<ContentItem> dynamicTitlePrefix = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.DynamicTitlePrefix, contentManager);
var whatItTakesData = await _whatItTakesMessageConverter.ConvertFromAsync(contentItem);
IEnumerable<ContentItem> workingHoursDetails = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.WorkingHoursDetails, contentManager);
IEnumerable<ContentItem> workingPatterns = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.WorkingPattern, contentManager);
IEnumerable<ContentItem> workingPatternDetails = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.WorkingPatternDetails, contentManager);
IEnumerable<ContentItem> hiddenAlternativeTitle = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.HiddenAlternativeTitle, contentManager);
IEnumerable<ContentItem> jobProfileSpecialism = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.JobProfileSpecialism, contentManager);
IEnumerable<ContentItem> jobCategories = await Helper.GetContentItemsAsync(contentItem.Content.JobProfile.JobProfileCategory, contentManager);
var jobProfileMessage = new JobProfileMessage
{
JobProfileId = contentItem.As<GraphSyncPart>().ExtractGuid(),
Title = contentItem.As<TitlePart>().Title,
UrlName = contentItem.As<PageLocationPart>().UrlName,
WidgetContentTitle = contentItem.Content.JobProfile.WidgetContentTitle is null ? default : (string?)contentItem.Content.JobProfile.WidgetContentTitle.Text,
AlternativeTitle = contentItem.Content.JobProfile.AlternativeTitle is null ? default : (string?)contentItem.Content.JobProfile.AlternativeTitle.Text,
Overview = contentItem.Content.JobProfile.Overview is null ? default : (string?)contentItem.Content.JobProfile.Overview.Text,
SalaryStarter = contentItem.Content.JobProfile.Salarystarterperyear is null ? default : (decimal?)contentItem.Content.JobProfile.Salarystarterperyear.Value,
SalaryExperienced = contentItem.Content.JobProfile.Salaryexperiencedperyear is null ? default : (decimal?)contentItem.Content.JobProfile.Salaryexperiencedperyear.Value,
MinimumHours = contentItem.Content.JobProfile.Minimumhours is null ? default : (decimal?)contentItem.Content.JobProfile.Minimumhours.Value,
MaximumHours = contentItem.Content.JobProfile.Maximumhours is null ? default : (decimal?)contentItem.Content.JobProfile.Maximumhours.Value,
CareerPathAndProgression = contentItem.Content.JobProfile.Careerpathandprogression is null ? default : (string?)contentItem.Content.JobProfile.Careerpathandprogression.Html,
CourseKeywords = contentItem.Content.JobProfile.Coursekeywords is null ? default : (string?)contentItem.Content.JobProfile.Coursekeywords.Text,
HowToBecomeData = await _howToBecomeMessageConverter.ConvertFromAsync(contentItem),
WhatYouWillDoData = await _whatYouWillDoDataMessageConverter.ConvertFromAsync(contentItem),
RelatedCareersData = GetRelatedCareersData(relatedCareersProfiles),
DynamicTitlePrefix = dynamicTitlePrefix?.FirstOrDefault()?.As<TitlePart>()?.Title ?? string.Empty,
WorkingHoursDetails = Helper.MapClassificationData(workingHoursDetails),
WorkingPattern = Helper.MapClassificationData(workingPatterns),
WorkingPatternDetails = Helper.MapClassificationData(workingPatternDetails),
HiddenAlternativeTitle = Helper.MapClassificationData(hiddenAlternativeTitle),
JobProfileSpecialism = Helper.MapClassificationData(jobProfileSpecialism),
SocSkillsMatrixData = whatItTakesData.RelatedSocSkillMatrixSkills,
DigitalSkillsLevel = whatItTakesData.RelatedDigitalSkills,
Restrictions = whatItTakesData.RelatedRestrictions,
OtherRequirements = whatItTakesData.OtherRequirements,
SocCodeData = await _socCodeMessageConverter.ConvertFromAsync(contentItem),
IncludeInSitemap = !contentItem.As<SitemapPart>().Exclude,
JobProfileCategories = GetJobCategories(jobCategories),
};
jobProfileMessage.CanonicalName = !string.IsNullOrEmpty(jobProfileMessage.UrlName) ? jobProfileMessage.UrlName.ToLower() : string.Empty;
jobProfileMessage.SocLevelTwo = !string.IsNullOrEmpty(jobProfileMessage.SocCodeData?.SOCCode) ? jobProfileMessage.SocCodeData.SOCCode.Substring(0, 2) : string.Empty;
if (contentItem.ModifiedUtc.HasValue)
{
jobProfileMessage.LastModified = contentItem.ModifiedUtc.Value;
}
return jobProfileMessage;
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw;
}
}
private static IEnumerable<JobProfileCategoryItem> GetJobCategories(IEnumerable<ContentItem> contentItems) =>
contentItems?.Select(contentItem => new JobProfileCategoryItem
{
Id = contentItem.As<GraphSyncPart>().ExtractGuid(),
Title = contentItem.As<TitlePart>().Title,
Name = contentItem.Content.JobProfileCategory.Description is null ? default : (string?)contentItem.Content.JobProfileCategory.Description.Text
}) ?? Enumerable.Empty<JobProfileCategoryItem>();
private static IEnumerable<JobProfileRelatedCareerItem> GetRelatedCareersData(IEnumerable<ContentItem> contentItems) =>
contentItems?.Select(contentItem => new JobProfileRelatedCareerItem
{
Id = contentItem.As<GraphSyncPart>().ExtractGuid(),
Title = contentItem.As<TitlePart>().Title,
ProfileLink = contentItem.As<PageLocationPart>().FullUrl
}) ?? Enumerable.Empty<JobProfileRelatedCareerItem>();
}
}
|
/*-------------------------------------------------------------------------------------------
* Copyright (c) Fuyuno Mikazuki / Natsuneko. All rights reserved.
* Licensed under the MIT License. See LICENSE in the project root for license information.
*------------------------------------------------------------------------------------------*/
using System.Collections.Generic;
using Mochizuki.VariationPackager.Models.Interface;
using Newtonsoft.Json;
namespace Mochizuki.VariationPackager.Models.Json
{
public class PackageConfiguration : IPackageConfiguration
{
[JsonProperty("name")]
public string Name { get; set; }
[JsonProperty("basedir")]
public string BaseDir { get; set; }
[JsonProperty("includes")]
public List<string> Includes { get; set; }
[JsonProperty("excludes")]
public List<string> Excludes { get; set; }
}
} |
using System;
using System.Net.Mail;
namespace InvoiceSOLIDApp {
public class Invoice
{
public long Amount { get; set; }
public DateTime InvoiceDate { get; set; }
private readonly Logger _logger;
private readonly MailSender _mailSender;
protected Invoice()
{
_logger = new Logger();
_mailSender = new MailSender();
}
protected void Add()
{
try
{
_logger.Info("Add method Start");
// Code for adding invoice
// Once Invoice has been added , send mail
_mailSender.From = "rakesh.girase@thedigitalgroup.net";
_mailSender.To = "customers@digitalgroup.com";
_mailSender.Subject = "TestMail";
_mailSender.Body = "This is a text mail";
_mailSender.SendEmail();
}
catch (Exception ex)
{
_logger.Error("Error while Adding Invoice", ex);
}
}
protected void Delete()
{
try
{
_logger.Info("Add Delete Start");
// Code for Delete invoice
}
catch (Exception ex)
{
_logger.Error("Error while Deleting Invoice", ex);
}
}
}
}
|
using System.Linq;
using HtmlAgilityPack;
using NeuroLinker.Models;
namespace NeuroLinker.Extensions
{
/// <summary>
/// Scrape user information from an Anime page
/// </summary>
public static class UserInformationScrapingExtensions
{
#region Public Methods
/// <summary>
/// Retrieve the user's current watched episode
/// </summary>
/// <param name="anime">Anime instance to populate</param>
/// <param name="doc">Html document from which data should be pulled</param>
/// <returns>Anime instance</returns>
public static Anime RetrieveUserEpisode(this Anime anime, HtmlDocument doc)
{
var episodeNode = doc.DocumentNode
.SelectSingleNode("//input[@type='text' and @name='myinfo_watchedeps']")
.Attributes["value"]
.Value;
if (int.TryParse(episodeNode, out var episodeWatched))
{
anime.UserWatchedEpisodes = episodeWatched;
}
return anime;
}
/// <summary>
/// Retrieves the user's Score
/// </summary>
/// <param name="anime">Anime instance to populate</param>
/// <param name="doc">Html document from which data should be pulled</param>
/// <returns>Anime instance</returns>
public static Anime RetrieveUserScore(this Anime anime, HtmlDocument doc)
{
var scoreNode = doc.DocumentNode
.SelectSingleNode("//select[@name='myinfo_score']")
.ChildNodes
.FirstOrDefault(x => x.GetAttributeValue("selected", "") == "selected")
?.Attributes["value"]
.Value;
if (int.TryParse(scoreNode, out var userScore))
{
anime.UserScore = userScore;
}
return anime;
}
/// <summary>
/// Retrieve the user's Watch status
/// </summary>
/// <param name="anime">Anime instance to populate</param>
/// <param name="doc">Html document from which data should be pulled</param>
/// <returns>Anime instance</returns>
public static Anime RetrieveUserStatus(this Anime anime, HtmlDocument doc)
{
var statusNode = doc.DocumentNode
.SelectSingleNode("//select[@name='myinfo_status']")
.ChildNodes
.FirstOrDefault(x => x.GetAttributeValue("selected", "") == "selected");
anime.UserWatchedStatus = statusNode?.InnerText;
return anime;
}
#endregion
}
} |
using System;
using Framework.Data;
using System.Data;
using System.Data.SqlClient;
using Xunit;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
using System.Reflection;
using System.Threading;
using System.Diagnostics;
using static Framework.Data.ModelWrapper;
using static Framework.Test.Helper;
namespace Framework.Test
{
public sealed class DataTest
{
private static T QueryData<T>(string sql)
{
using (var conn = OpenConnection())
{
return conn.Query<T>(sql).FirstOrDefault();
}
}
#region 非IDataModel物件
internal sealed class NonInterfaceClass
{
public string strCol1;
public string strCol2 { get; set; }
internal string strCol3;
internal string strCol4 { get; set; }
public StringEnum strEnum { get; set; }
}
[Fact(DisplayName = "非IDataModel物件-參數")]
public void NonInterfaceClassParam()
{
var model = new NonInterfaceClass { strCol1 = "3", strCol2 = "4", strCol3 = "5", strCol4 = "6", strEnum = StringEnum.B };
var sqlStr = @"select * from tabA where strCol1=@strCol1 and strCol2=@strCol2 and strCol3=@strCol3 and strCol4=@strCol4 and strEnum=@strEnum";
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(2, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("strCol2", model.strCol2, DbType.String, 4000)
.Verify("strEnum", "bb", DbType.String, 4000);
}
[Fact(DisplayName = "非IDataModel物件-查詢")]
public void NonInterfaceClassQuery()
{
var model = QueryData<NonInterfaceClass>("select 'a' strCol1, 'b' strCol2, 'c' strCol3, 'd' strCol4, 'bb' strEnum");
Assert.Equal(null, model.strCol1);
Assert.Equal("b", model.strCol2);
Assert.Equal(null, model.strCol3);
Assert.Equal(null, model.strCol4);
Assert.Equal(StringEnum.B, model.strEnum);
model = QueryData<NonInterfaceClass>("select null strCol1, null strCol2, null strCol3, null strCol4, null strEnum");
Assert.Equal(null, model.strCol1);
Assert.Equal(null, model.strCol2);
Assert.Equal(null, model.strCol3);
Assert.Equal(null, model.strCol4);
Assert.Equal(default(StringEnum), model.strEnum);
}
#endregion
#region 非IDataModel結構
internal struct NonInterfaceStruct
{
public string strCol1;
public string strCol2 { get; set; }
internal string strCol3;
internal string strCol4 { get; set; }
public StringEnum strEnum { get; set; }
}
[Fact(DisplayName = "非IDataModel結構-參數")]
public void NonInterfaceStructParam()
{
var model = new NonInterfaceStruct { strCol1 = "3", strCol2 = "4", strCol3 = "5", strCol4 = "6", strEnum = StringEnum.B };
var sqlStr = @"select * from tabA where strCol1=@strCol1 and strCol2=@strCol2 and strCol3=@strCol3 and strCol4=@strCol4 and strEnum=@strEnum";
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(2, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("strCol2", model.strCol2, DbType.String, 4000)
.Verify("strEnum", "bb", DbType.String, 4000);
}
[Fact(DisplayName = "非IDataModel結構-查詢")]
public void NonInterfaceStructQuery()
{
var model = QueryData<NonInterfaceStruct>("select 'a' strCol1, 'b' strCol2, 'c' strCol3, 'd' strCol4, 'bb' strEnum");
Assert.Equal(null, model.strCol1);
Assert.Equal("b", model.strCol2);
Assert.Equal(null, model.strCol3);
Assert.Equal(null, model.strCol4);
Assert.Equal(StringEnum.B, model.strEnum);
model = QueryData<NonInterfaceStruct>("select null strCol1, null strCol2, null strCol3, null strCol4, null strEnum");
Assert.Equal(null, model.strCol1);
Assert.Equal(null, model.strCol2);
Assert.Equal(null, model.strCol3);
Assert.Equal(null, model.strCol4);
Assert.Equal(default(StringEnum), model.strEnum);
}
#endregion
#region PublicInternalModel
internal sealed class PublicInternalModel : IDbModel
{
public string strCol1;
public string strCol2 { get; set; }
[Column]
internal string strCol3;
[Column]
internal string strCol4 { get; set; }
[NonColumn]
public string nonCol1;
[NonColumn]
public string nonCol2 { get; set; }
internal string nonCol3;
internal string nonCol4 { get; set; }
}
[Fact(DisplayName = "public 與 internal物件-參數")]
public void PublicInternalParam()
{
var model = new PublicInternalModel {
strCol1 = "3", strCol2 = "4", strCol3 = "5", strCol4 = "6",
nonCol1 = "a", nonCol2 = "b", nonCol3 = "c", nonCol4 = "d"
};
var sqlStr = @"select * from tabA where
strCol1=@strCol1 and strCol2=@strCol2 and strCol3=@strCol3 and strCol4=@strCol4 and
nonCol1=@nonCol1 and nonCol2=@nonCol2 and nonCol3=@nonCol3 and nonCol4=@nonCol4";
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(4, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("strCol1", model.strCol1, DbType.String, 4000)
.Verify("strCol2", model.strCol2, DbType.String, 4000)
.Verify("strCol3", model.strCol3, DbType.String, 4000)
.Verify("strCol4", model.strCol4, DbType.String, 4000);
}
[Fact(DisplayName = "public 與 internal物件-查詢")]
public void PublicInternalQuery()
{
var model = QueryData<PublicInternalModel>("select 'a' strCol1, 'b' strCol2, 'c' strCol3, 'd' strCol4, 'a1' nonCol1, 'a2' nonCol2, 'a3' nonCol3, 'a4' nonCol4");
Assert.Equal("a", model.strCol1);
Assert.Equal("b", model.strCol2);
Assert.Equal("c", model.strCol3);
Assert.Equal("d", model.strCol4);
Assert.Equal(null, model.nonCol1);
Assert.Equal(null, model.nonCol2);
Assert.Equal(null, model.nonCol3);
Assert.Equal(null, model.nonCol4);
model = QueryData<PublicInternalModel>("select null strCol1, null strCol2, null strCol3, null strCol4, null nonCol1, null nonCol2, null nonCol3, null nonCol4");
Assert.Equal(null, model.strCol1);
Assert.Equal(null, model.strCol2);
Assert.Equal(null, model.strCol3);
Assert.Equal(null, model.strCol4);
Assert.Equal(null, model.nonCol1);
Assert.Equal(null, model.nonCol2);
Assert.Equal(null, model.nonCol3);
Assert.Equal(null, model.nonCol4);
}
#endregion
#region PublicInternalStruct
internal struct PublicInternalStruct : IDbModel
{
public string strCol1;
public string strCol2 { get; set; }
[Column]
internal string strCol3;
[Column]
internal string strCol4 { get; set; }
[NonColumn]
public string nonCol1;
[NonColumn]
public string nonCol2 { get; set; }
internal string nonCol3;
internal string nonCol4 { get; set; }
}
[Fact(DisplayName = "public 與 internal結構-參數")]
public void PublicInternalStructParam()
{
var model = new PublicInternalStruct
{
strCol1 = "3",
strCol2 = "4",
strCol3 = "5",
strCol4 = "6",
nonCol1 = "a",
nonCol2 = "b",
nonCol3 = "c",
nonCol4 = "d"
};
var sqlStr = @"select * from tabA where
strCol1=@strCol1 and strCol2=@strCol2 and strCol3=@strCol3 and strCol4=@strCol4 and
nonCol1=@nonCol1 and nonCol2=@nonCol2 and nonCol3=@nonCol3 and nonCol4=@nonCol4";
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(4, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("strCol1", model.strCol1, DbType.String, 4000)
.Verify("strCol2", model.strCol2, DbType.String, 4000)
.Verify("strCol3", model.strCol3, DbType.String, 4000)
.Verify("strCol4", model.strCol4, DbType.String, 4000);
}
[Fact(DisplayName = "public 與 internal結構-查詢")]
public void PublicInternalStructQuery()
{
var model = QueryData<PublicInternalStruct>("select 'a' strCol1, 'b' strCol2, 'c' strCol3, 'd' strCol4, 'a1' nonCol1, 'a2' nonCol2, 'a3' nonCol3, 'a4' nonCol4");
Assert.Equal("a", model.strCol1);
Assert.Equal("b", model.strCol2);
Assert.Equal("c", model.strCol3);
Assert.Equal("d", model.strCol4);
Assert.Equal(null, model.nonCol1);
Assert.Equal(null, model.nonCol2);
Assert.Equal(null, model.nonCol3);
Assert.Equal(null, model.nonCol4);
model = QueryData<PublicInternalStruct>("select null strCol1, null strCol2, null strCol3, null strCol4, null nonCol1, null nonCol2, null nonCol3, null nonCol4");
Assert.Equal(null, model.strCol1);
Assert.Equal(null, model.strCol2);
Assert.Equal(null, model.strCol3);
Assert.Equal(null, model.strCol4);
Assert.Equal(null, model.nonCol1);
Assert.Equal(null, model.nonCol2);
Assert.Equal(null, model.nonCol3);
Assert.Equal(null, model.nonCol4);
}
#endregion
#region EnumMapping
public enum StringEnum
{
[DbValue("aa")]
A,
[DbValue("bb")]
B,
[DbValue("cc")]
C
}
public enum NormalEnum
{
A = 1,
B = 2,
C = 3
}
public sealed class EnumMappingModel : IDbModel
{
public NormalEnum norEnum;
public StringEnum strEnum;
public string strCol;
public int intCol;
public decimal decimalCol;
public DateTime datetimeCol;
public DateTimeOffset dateoffsetCol;
}
[Fact(DisplayName = "列舉對應-參數")]
public void EnumMappingParam()
{
var sqlStr = @"select * from tabA where
norEnum=@norEnum and strEnum=@strEnum and strCol=@strCol and intCol=@intCol and decimalCol=@decimalCol and
datetimeCol=@datetimeCol and dateoffsetCol=@dateoffsetCol";
var model = new EnumMappingModel { norEnum = NormalEnum.B, strEnum = StringEnum.B, strCol = "abcd", intCol = 10, decimalCol = 10, datetimeCol = DateTime.Now, dateoffsetCol = DateTimeOffset.Now };
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(7, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify(nameof(EnumMappingModel.norEnum), (int)model.norEnum, DbType.Int32)
.Verify(nameof(EnumMappingModel.strEnum), "bb", DbType.String, 4000)
.Verify(nameof(EnumMappingModel.strCol), "abcd", DbType.String, 4000)
.Verify(nameof(EnumMappingModel.intCol), model.intCol, DbType.Int32)
.Verify(nameof(EnumMappingModel.decimalCol), model.decimalCol, DbType.Decimal)
.Verify(nameof(EnumMappingModel.datetimeCol), model.datetimeCol, DbType.DateTime)
.Verify(nameof(EnumMappingModel.dateoffsetCol), model.dateoffsetCol, DbType.DateTimeOffset);
}
[Fact(DisplayName = "列舉對應-查詢")]
public void EnumMappingQuery()
{
var model = QueryData<EnumMappingModel>(@"
select 2 norEnum, 'bb' strEnum, 'c' strCol, 1 intCol, 1.5 decimalCol,
convert(datetime,'2017/02/28 12:34') datetimeCol, convert(datetimeoffset,'2017/02/28 12:34+6:33') dateoffsetCol ");
Assert.Equal((NormalEnum)2, model.norEnum);
Assert.Equal(StringEnum.B, model.strEnum);
Assert.Equal("c", model.strCol);
Assert.Equal(1, model.intCol);
Assert.Equal(1.5m, model.decimalCol);
Assert.Equal(new DateTime(2017, 2, 28, 12, 34, 0), model.datetimeCol);
Assert.Equal(new DateTimeOffset(2017, 2, 28, 12, 34, 0, new TimeSpan(6,33,0)), model.dateoffsetCol);
model = QueryData<EnumMappingModel>(@"
select null norEnum, null strEnum, null strCol, null intCol, null decimalCol,
convert(datetime,null) datetimeCol, convert(datetimeoffset,null) dateoffsetCol ");
Assert.Equal(default(NormalEnum), model.norEnum);
Assert.Equal(default(StringEnum), model.strEnum);
Assert.Equal(null, model.strCol);
Assert.Equal(default(int), model.intCol);
Assert.Equal(default(DateTime), model.datetimeCol);
Assert.Equal(default(DateTimeOffset), model.dateoffsetCol);
}
#endregion
#region Nullable
internal sealed class NullableModel : IDbModel
{
public NormalEnum? norEnum;
public StringEnum? strEnum;
public string strCol;
public int? intCol;
public decimal? decimalCol;
}
[Fact(DisplayName = "Nullable-參數")]
public void NullableParam()
{
var model = new NullableModel { norEnum = NormalEnum.B, strEnum = StringEnum.B, strCol = "abcd", intCol = 10, decimalCol = null };
var sqlStr = @"select * from tabA where norEnum=@norEnum and strEnum=@strEnum and strCol=@strCol and intCol=@intCol and decimalCol=@decimalCol";
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(5, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("norEnum", 2, DbType.Int32)
.Verify("strEnum", "bb", DbType.String, 4000)
.Verify("strCol", "abcd", DbType.String, 4000)
.Verify("intCol", 10, DbType.Int32)
.Verify("decimalCol", DBNull.Value, DbType.Decimal);
model = new NullableModel();
commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(5, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("norEnum", DBNull.Value, DbType.Int32)
.Verify("strEnum", DBNull.Value, DbType.String, 0)
.Verify("strCol", DBNull.Value, DbType.String, 0)
.Verify("intCol", DBNull.Value, DbType.Int32)
.Verify("decimalCol", DBNull.Value, DbType.Decimal);
}
[Fact(DisplayName = "Nullable-查詢")]
public void NullableQuery()
{
var model = QueryData<NullableModel>("select 2 norEnum, 'bb' strEnum, 'c' strCol, 1 intCol, 1.5 decimalCol");
Assert.Equal((NormalEnum)2, model.norEnum);
Assert.Equal(StringEnum.B, model.strEnum);
Assert.Equal("c", model.strCol);
Assert.Equal(1, model.intCol);
Assert.Equal(1.5m, model.decimalCol);
model = QueryData<NullableModel>("select null norEnum, null strEnum, null strCol, null intCol, null decimalCol");
Assert.Equal(null, model.norEnum);
Assert.Equal(null, model.strEnum);
Assert.Equal(null, model.strCol);
Assert.Equal(null, model.intCol);
Assert.Equal(null, model.decimalCol);
}
#endregion
#region NullMapping
public sealed class NullMappingModel : IDbModel
{
[Column(NullDbValue = 10)]
public NormalEnum? norEnum;
[Column(NullDbValue = "A")]
public StringEnum? strEnum;
[Column(NullDbValue = 2D)] //docuble
public string strCol;
[Column(NullDbValue = 3L)] //long
public int? intCol;
[Column(NullDbValue = NormalEnum.A)]
public decimal? decimalCol;
}
[Fact(DisplayName = "NullMapping-參數")]
public void NullMappingParam()
{
var model = new NullMappingModel();
var sqlStr = @"select * from tabA where norEnum=@norEnum and strEnum=@strEnum and strCol=@strCol and intCol=@intCol and decimalCol=@decimalCol";
var commandInfo = GetCommandInfos(sqlStr, model).First();
Assert.Equal(5, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("norEnum", 10, DbType.Int32)
.Verify("strEnum", "A", DbType.String, 4000)
.Verify("strCol", 2D, DbType.Double)
.Verify("intCol", 3L, DbType.Int64)
.Verify("decimalCol", 1, DbType.Int32);
}
[Fact(DisplayName = "NullMapping-查詢")]
public void NullMappingQuery()
{
var model = QueryData<NullMappingModel>("select 3 norEnum, 'cc' strEnum, '4' strCol, 10 intCol, 5 decimalCol");
Assert.Equal(NormalEnum.C, model.norEnum);
Assert.Equal(StringEnum.C, model.strEnum);
Assert.Equal("4", model.strCol);
Assert.Equal(10, model.intCol);
Assert.Equal(5, model.decimalCol);
model = QueryData<NullMappingModel>("select 10 norEnum, 'A' strEnum, 2 strCol, 3 intCol, 1 decimalCol");
Assert.Equal(null, model.norEnum);
Assert.Equal(null, model.strEnum);
Assert.Equal(null, model.strCol);
Assert.Equal(null, model.intCol);
Assert.Equal(null, model.decimalCol);
model = QueryData<NullMappingModel>("select null norEnum, null strEnum, null strCol, null intCol, null decimalCol");
Assert.Equal(null, model.norEnum);
Assert.Equal(null, model.strEnum);
Assert.Equal(null, model.strCol);
Assert.Equal(null, model.intCol);
Assert.Equal(null, model.decimalCol);
}
#endregion
#region 集合
[Fact(DisplayName = "參數為複數值")]
public void EnumerableParamValue()
{
var sqlStr = @"select * from tabA col in @col";
var commandInfo = GetCommandInfos(sqlStr, new { col = new[] { "A", null, "C" } }).First();
Assert.Equal("select * from tabA col in (@col1,@col2,@col3)", commandInfo.CommandText);
Assert.Equal(3, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("col1", "A", DbType.String, 4000)
.Verify("col2", DBNull.Value, DbType.String, 4000) //總感覺這邊應該要是0才對,而不是4000
.Verify("col3", "C", DbType.String, 4000);
commandInfo = GetCommandInfos(sqlStr, new { col = new StringEnum?[] { StringEnum.A, null, StringEnum.C } }).First();
Assert.Equal("select * from tabA col in (@col1,@col2,@col3)", commandInfo.CommandText);
Assert.Equal(3, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("col1", "aa", DbType.String, 4000)
.Verify("col2", DBNull.Value, DbType.String, 4000) //總感覺這邊應該要是0才對,而不是4000
.Verify("col3", "cc", DbType.String, 4000);
}
[Fact(DisplayName = "多個參數")]
public void EnumerableModel()
{
using (var conn = OpenConnection())
{
using (var trace = new DbTraceContext())
{
var tmpTable = conn.CreateTempTable<NullMappingModel>();
var insertModels = new[]
{
new NullMappingModel { norEnum = NormalEnum.A, strEnum = StringEnum.A },
new NullMappingModel { norEnum = NormalEnum.B, strEnum = StringEnum.B },
new NullMappingModel { norEnum = null, strEnum = null }
};
Assert.Equal(insertModels.Length, conn.Execute($"insert into {tmpTable} (norEnum, strEnum) values (@norEnum, @strEnum)", insertModels));
var updateModels = insertModels.Select(n => new NullMappingModel { norEnum = n.norEnum, strEnum = StringEnum.C }).ToList();
Assert.Equal(updateModels.Count, conn.Execute($"update {tmpTable} set strEnum = @strEnum where norEnum = @norEnum", updateModels));
var selectModels = conn.Query<NullMappingModel>($"select * from {tmpTable}").ToList();
Assert.True(updateModels.OrderBy(n => n.norEnum).Select(n => n.strCol).SequenceEqual(selectModels.OrderBy(n => n.norEnum).Select(n => n.strCol)));
Assert.Equal(updateModels.Count, conn.Execute($"delete from {tmpTable} where norEnum = @norEnum", updateModels));
conn.Execute($"drop table {tmpTable}");
}
}
}
#endregion
#region
[Fact(DisplayName = "字典")]
public void DictionaryParam()
{
//一般資料
var sqlStr = @"select * from tabA col1 = @col1 and col2 = @col2";
var commandInfo = GetCommandInfos(sqlStr, new Dictionary<string, object>
{
["col1"] = "A",
["col2"] = "B",
}).First();
Assert.Equal(2, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("col1", "A", DbType.String, 4000)
.Verify("col2", "B", DbType.String, 4000);
//有EnumValue
commandInfo = GetCommandInfos(sqlStr, new Dictionary<string, object>
{
["col1"] = StringEnum.A,
["col2"] = StringEnum.B,
}).First();
Assert.Equal(2, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("col1", "aa", DbType.String, 4000)
.Verify("col2", "bb", DbType.String, 4000);
//EnumValue的集合
commandInfo = GetCommandInfos("select * from tabA col in @col", new Dictionary<string, object>
{
["col"] = new[] { StringEnum.A, StringEnum.B }
}).First();
Assert.Equal("select * from tabA col in (@col1,@col2)", commandInfo.CommandText);
Assert.Equal(2, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("col1", "aa", DbType.String, 4000)
.Verify("col2", "bb", DbType.String, 4000);
//DynamicParameters
var param = new DynamicParameters(new { col = StringEnum.A });
commandInfo = GetCommandInfos("select * from tabA col = @col", param).First();
Assert.Equal(1, commandInfo.Parameters.Count);
commandInfo.Parameters.Verify("col", "aa", DbType.String, 4000);
//DynamicParameters Enumerable
param = new DynamicParameters(new { col = new[] { StringEnum.A, StringEnum.B } });
commandInfo = GetCommandInfos("select * from tabA col in @col", param).First();
Assert.Equal("select * from tabA col in (@col1,@col2)", commandInfo.CommandText);
Assert.Equal(2, commandInfo.Parameters.Count);
commandInfo.Parameters
.Verify("col1", "aa", DbType.String, 4000)
.Verify("col2", "bb", DbType.String, 4000);
}
#endregion
private static IEqualityComparer equalityComparer = EqualityComparer<Type[]>.Default;
#region 單值查詢
[Fact(DisplayName = "單值查詢")]
public void QueryValue()
{
var node = new[] { typeof(int), typeof(int), typeof(int) };
var dictA = new HashSet<Type[]>();
dictA.Add(new[] { typeof(int), typeof(int), typeof(int) });
var dictB = new HashSet<int>();
dictB.Add(node.GetHashCode());
var dictC = new HashSet<int>();
dictC.Add(StructuralComparisons.StructuralEqualityComparer.GetHashCode(node));
var watch = new Stopwatch();
watch.Restart();
for (var i = 0; i < 10000; i++) dictA.Contains(node);
Trace.WriteLine(watch.ElapsedTicks);
watch.Restart();
for (var i = 0; i < 10000; i++)
{
var hashCode = 17;
foreach (var t in node)
{
hashCode = hashCode * 23 + (t?.GetHashCode() ?? 0);
}
dictB.Contains(hashCode);
};
Trace.WriteLine(watch.ElapsedTicks);
watch.Restart();
for (var i = 0; i < 10000; i++) dictC.Contains(StructuralComparisons.StructuralEqualityComparer.GetHashCode(node));
Trace.WriteLine(watch.ElapsedTicks);
Assert.Equal(3, QueryData<int>("select 3"));
Assert.Equal("aaa", QueryData<string>("select 'aaa'"));
Assert.Equal('a', QueryData<char>("select 'a'"));
Assert.Equal(null, QueryData<int?>("select null"));
Assert.Equal(NormalEnum.B, QueryData<NormalEnum>("select 2"));
Assert.Equal(NormalEnum.B, QueryData<NormalEnum>("select 'B'"));
Assert.Throws<Exception>(() => QueryData<NormalEnum>("select convert(varchar, null)"));
Assert.Equal(null, QueryData<NormalEnum?>("select convert(varchar, null)"));
}
#endregion
#region Model轉Dictionary
public sealed class DictionaryModel : IDbModel
{
public int intCol;
[Column(NullDbValue = "A")]
public NormalEnum? nullNorEnum;
[Column(NullDbValue = 10)]
public StringEnum? nullStrEnum;
[Column(NullDbValue = 2D)] //double
public string strCol;
[Column(NullDbValue = 3L)] //long
public int? nullIntCol;
[Column(NullDbValue = NormalEnum.A)]
public decimal? nullDecimalCol;
[Column(NullDbValue = 10)]
public StringEnum?[] nullStrEnumArray;
}
[Fact(DisplayName = "Model轉Dictionary")]
public void Model轉Dictionary()
{
var model = new DictionaryModel
{
intCol = 30,
nullDecimalCol = 10,
nullIntCol = 20,
nullNorEnum = NormalEnum.B,
strCol = "a",
nullStrEnum = StringEnum.C,
nullStrEnumArray = new StringEnum?[] { StringEnum.A, StringEnum.B, StringEnum.C }
};
var dict = DbModelHelper.ToDictionary(model);
Assert.Equal(model.intCol, dict[nameof(DictionaryModel.intCol)]);
Assert.Equal((int)model.nullNorEnum, dict[nameof(DictionaryModel.nullNorEnum)]);
Assert.Equal("cc", dict[nameof(DictionaryModel.nullStrEnum)]);
Assert.Equal(model.strCol, dict[nameof(DictionaryModel.strCol)]);
Assert.Equal(model.nullIntCol, dict[nameof(DictionaryModel.nullIntCol)]);
Assert.Equal(model.nullDecimalCol, dict[nameof(DictionaryModel.nullDecimalCol)]);
Assert.True(((IEnumerable<object>)dict[nameof(DictionaryModel.nullStrEnumArray)]).SequenceEqual(new object[] { "aa", "bb", "cc" }));
// null mapping
model = new DictionaryModel { nullStrEnumArray = new StringEnum?[] { null, null, null } };
dict = DbModelHelper.ToDictionary(model);
Assert.Equal("A", dict[nameof(DictionaryModel.nullNorEnum)]);
Assert.Equal(10, dict[nameof(DictionaryModel.nullStrEnum)]);
Assert.Equal(2D, dict[nameof(DictionaryModel.strCol)]);
Assert.Equal(3L, dict[nameof(DictionaryModel.nullIntCol)]);
Assert.Equal(NormalEnum.A, dict[nameof(DictionaryModel.nullDecimalCol)]);
Assert.True(((IEnumerable<object>)dict[nameof(DictionaryModel.nullStrEnumArray)]).SequenceEqual(new object[] { 10, 10, 10 }));
}
#endregion
#region join
class User
{
public int Id { get; set; }
public string Name { get; set; }
}
class Post
{
public int Id { get; set; }
public User Owner { get; set; }
public string Content { get; set; }
}
[Fact(DisplayName = "Multi Map")]
public void TestMultiMap()
{
var createSql = @"
create table #Users (Id int, Name varchar(20))
create table #Posts (Id int, OwnerId int, Content varchar(20))
insert #Users values(99, 'Sam')
insert #Users values(2, 'I am')
insert #Posts values(1, 99, 'Sams Post1')
insert #Posts values(2, 99, 'Sams Post2')
insert #Posts values(3, null, 'no ones post')";
using (var conn = OpenConnection())
{
conn.Execute(createSql);
var sql = @"select * from #Posts p left join #Users u on u.Id = p.OwnerId Order by p.Id";
var data = conn.Query<Post, User, Post>(sql, (post, user) => { post.Owner = user; return post; }).ToList();
var p = data.First();
Assert.Equal("Sams Post1", p.Content);
Assert.Equal(1, p.Id);
Assert.Equal("Sam", p.Owner.Name);
Assert.Equal(99, p.Owner.Id);
Assert.Null(data[2].Owner);
conn.Execute("drop table #Users drop table #Posts");
}
}
#endregion
#region member default value
public class MemberDefaultModel : IDbModel
{
public int intNoneDefault { get; set; }
public int colInt { get; set; } = 10;
public int? colIntNull = 20;
public int? colIntNull2 { get; set; } = 20;
public string strNoneDefault { get; set; }
public string colStr { get; set; } = "a";
}
[Fact(DisplayName = "member有預設值")]
public void TestMemberDefaultValue()
{
using (var conn = OpenConnection())
{
var sqlStr = "select" +
" convert(int, null) intNoneDefault," +
" convert(int, null) colInt," +
" convert(int, null) colIntNull," +
" convert(varchar, null) strNoneDefault," +
" convert(varchar, null) colStr";
var data = conn.Query<MemberDefaultModel>(sqlStr).First();
Assert.Equal(default(int), data.intNoneDefault);
Assert.Equal(10, data.colInt);
Assert.Null(data.colIntNull);
Assert.Null(data.strNoneDefault);
Assert.Null(data.colStr);
}
}
#endregion
[Fact(DisplayName = "ValueTuple")]
public void TestValueTuple()
{
using (var conn = OpenConnection())
{
var val1 = conn.Query<(int id, string name)>("select 42, 'Fred'").First();
Assert.Equal(42, val1.id);
Assert.Equal("Fred", val1.name);
var val2 = conn.Query<(int id, string name)>("select 42, 'Fred', 123").First();
Assert.Equal(42, val2.id);
Assert.Equal("Fred", val2.name);
var val3 = conn.Query<(int id, string name, int extra)>("select 42, 'Fred'").First();
Assert.Equal(42, val3.id);
Assert.Equal("Fred", val3.name);
Assert.Equal(0, val3.extra);
//使用ValueTuple的時候，會忽略欄位名稱。
var val4 = conn.Query<(int id, string name)>("select 42 as [Item2], 'Fred' as [Item1]").First();
Assert.Equal(42, val4.id);
Assert.Equal("Fred", val4.name);
}
}
}
}
|
namespace Properties.Core.Interfaces
{
public interface IPropertyServiceFacade : IPropertyService, ILandlordService, IPropertySubmissionService
{
}
}
|
using Microsoft.EntityFrameworkCore.Migrations;
namespace ECommerce.Migrations
{
public partial class ThirdMigration : Migration
{
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropForeignKey(
name: "FK_Customers_Users_UserId",
table: "Customers");
migrationBuilder.RenameColumn(
name: "UserId",
table: "Customers",
newName: "SupplierUserId");
migrationBuilder.RenameIndex(
name: "IX_Customers_UserId",
table: "Customers",
newName: "IX_Customers_SupplierUserId");
migrationBuilder.AddColumn<int>(
name: "CustomerUserId",
table: "Customers",
nullable: false,
defaultValue: 0);
migrationBuilder.CreateIndex(
name: "IX_Customers_CustomerUserId",
table: "Customers",
column: "CustomerUserId");
migrationBuilder.AddForeignKey(
name: "FK_Customers_Users_CustomerUserId",
table: "Customers",
column: "CustomerUserId",
principalTable: "Users",
principalColumn: "UserId",
onDelete: ReferentialAction.Cascade);
migrationBuilder.AddForeignKey(
name: "FK_Customers_Users_SupplierUserId",
table: "Customers",
column: "SupplierUserId",
principalTable: "Users",
principalColumn: "UserId",
onDelete: ReferentialAction.Cascade);
}
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropForeignKey(
name: "FK_Customers_Users_CustomerUserId",
table: "Customers");
migrationBuilder.DropForeignKey(
name: "FK_Customers_Users_SupplierUserId",
table: "Customers");
migrationBuilder.DropIndex(
name: "IX_Customers_CustomerUserId",
table: "Customers");
migrationBuilder.DropColumn(
name: "CustomerUserId",
table: "Customers");
migrationBuilder.RenameColumn(
name: "SupplierUserId",
table: "Customers",
newName: "UserId");
migrationBuilder.RenameIndex(
name: "IX_Customers_SupplierUserId",
table: "Customers",
newName: "IX_Customers_UserId");
migrationBuilder.AddForeignKey(
name: "FK_Customers_Users_UserId",
table: "Customers",
column: "UserId",
principalTable: "Users",
principalColumn: "UserId",
onDelete: ReferentialAction.Cascade);
}
}
}
|
//using System;
//using System.IO;
//using DFC.ServiceTaxonomy.Neo4j.Configuration;
//using FakeItEasy;
//using KellermanSoftware.CompareNetObjects;
//using Microsoft.Extensions.Configuration;
//using Microsoft.Extensions.Options;
//namespace DFC.ServiceTaxonomy.IntegrationTests.Helpers
//{
// public sealed class GraphTestDatabaseCollectionFixture : IDisposable
// {
// public TestNeoGraphDatabase GraphTestDatabase { get; }
// public CompareLogic CompareLogic { get; }
// public GraphTestDatabaseCollectionFixture()
// {
// var configuration = new ConfigurationBuilder()
// .SetBasePath(Directory.GetCurrentDirectory())
// .AddJsonFile("appsettings.json", false)
// .AddJsonFile("appsettings.Development.json", optional: true)
// .AddEnvironmentVariables()
// .Build();
// Neo4jOptions neo4jOptions = configuration.GetSection("Neo4j").Get<Neo4jOptions>();
// var optionsMonitor = A.Fake<IOptionsMonitor<Neo4jOptions>>();
// A.CallTo(() => optionsMonitor.CurrentValue).Returns(neo4jOptions);
// GraphTestDatabase = new TestNeoGraphDatabase(optionsMonitor);
// CompareLogic = new CompareLogic();
// CompareLogic.Config.IgnoreProperty<ExpectedNode>(n => n.Id);
// CompareLogic.Config.IgnoreProperty<ExpectedRelationship>(r => r.Id);
// CompareLogic.Config.IgnoreObjectTypes = true;
// CompareLogic.Config.SkipInvalidIndexers = true;
// CompareLogic.Config.MaxDifferences = 10;
// }
// public void Dispose()
// {
// GraphTestDatabase?.Dispose();
// }
// }
//}
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ClosePopUpMessage : MonoBehaviour
{
public GameObject popUpToClose = null;
public void ClosePopup(){
popUpToClose.SetActive(false);
}
}
|
using System;
namespace ConsoleApplication1
{
class Test : IDateAndCopy
{
public string Name { get; set; }
public bool Pass { get; set; }
public DateTime Date { get; set; }
public Test()
{
Name = "[default]";
Pass = false;
}
public Test(string name, bool pass)
{
Name = name;
Pass = pass;
}
public override string ToString()
{
return $"Test {Name} is {Pass}.";
}
public object DeepCopy()
{
return MemberwiseClone();
}
public override bool Equals(object obj)
{
if (obj == null) { return false; }
Test temp = (Test)obj;
return Name.Equals(temp.Name) && Pass.Equals(temp.Pass);
}
public static bool operator ==(Test test1, Test test2)
{
return ((object)test1 != null && test1.Equals(test2));
}
public static bool operator !=(Test test1, Test test2)
{
return !(test1 == test2);
}
public override int GetHashCode()
{
return new { Name, Pass }.GetHashCode();
}
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Page500GoFishStore
{
class Card : IComparable<Card>
{
public Suits Suit { get; }
public Values Value { get; }
private string _name;
public string Name
{
get
{
return _name;
}
}
public Card(Suits suit, Values value)
{
Suit = suit;
Value = value;
_name = $"{value} of {suit}";
}
public int CompareTo(Card other)
{
if (Value > other.Value)
{
return 1;
}
if (Value < other.Value)
{
return -1;
}
return 0;
}
public override string ToString()
{
return Name;
}
public static string Plural(Values value)
{
if (value == Values.Six)
{
return "Sixes";
}
return $"{value.ToString()}s";
}
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.IO;
using System.Data;
using SQMS.Services;
using EasyDev.Util;
namespace SQMS.Application.Views.Demo
{
public partial class UpdateQualityData : SQMSPage<UpdateQualityDataService>
{
private UpdateQualityDataService srv = null;
protected void Page_Load(object sender, EventArgs e)
{
Process();
}
/// <summary>
/// 质量数据存储规则：
/// 根目录下存放以设备名称命名的文件夹表示其中的内容由这个设备上传。
/// 每个设备文件夹中的文件的命名规则为“_+设备名+_+时间戳+_+<seqno>.扩展名”,seqno是序列号，用于标识分段视频，
/// 多段分段视频文件名的前面部分应该相同。注：多段视频不用单独放到一个文件夹中
/// </summary>
private void Process()
{
srv = Service as UpdateQualityDataService;
string phyDirBase = AppDomain.CurrentDomain.BaseDirectory + @"QualityData";
//取得所有以设备命名的目录
string[] dir = Directory.GetDirectories(phyDirBase);
DataSet QualityData = srv.LoadByKey("", false);
DataSet VideoData = srv.VideoService.LoadByKey("", false);
DataSet mvData = srv.mvService.LoadByKeys(null, false);
//遍历每一个设备目录
for (int i = 0; i < dir.Length; i++)
{
string[] files = null;
string currEquid = dir[i].Substring(dir[i].LastIndexOf("\\") + 1);
do
{
//查找目录中的带下划线的质量数据文件
files = Directory.GetFiles(dir[i], "_*.txt").
Concat<string>(Directory.GetFiles(dir[i], "_*.jpg")).ToArray<string>().
Concat<string>(Directory.GetFiles(dir[i], "_*.mpg")).ToArray<string>().
Concat<string>(Directory.GetFiles(dir[i], "_*.3gp")).ToArray<string>();
if (files.Length > 0)
{
DataRow drQuality = srv.Create();
DataRow drVideo = srv.VideoService.Create();
DataRow drMonitorVideo = srv.mvService.Create();
#region 处理质量数据文件
FileInfo fi = new FileInfo(files[0]);
//选择一组文件(相同文件名，不同类型的文件，即由同一设备一次上传的不同类型的文件)
IEnumerable<string> qd = files.Select<string, string>(
p =>
{
string tmp = p.Substring(p.LastIndexOf("\\") + 1);
if (tmp.Split(new char[] { '.' })[0].Contains(fi.Name.Substring(0, fi.Name.Length - fi.Extension.Length)))
return tmp;
else
return "";
});
IDictionary<string, string> empinfo = srv.FindUserInfoByEquID(currEquid);
drQuality["QMID"] = srv.GetNextSequenceID();
drQuality["ORGANIZATIONID"] = drQuality["WORKUNIT"] = empinfo["OrganizationID"];
drQuality["EMERGENCYPERSON"] = drQuality["CHECKPERSON"] = drQuality["CHARGEPERSON"] = empinfo["EmployeeID"];
drQuality["CREATEDBY"] = drQuality["MODIFIEDBY"] = empinfo["PassportID"];
drQuality["Status"] = "_normal";
IDictionary<string, string> filecontent = null;
//文本文件
//string filename = qd.First<string>(p => p.EndsWith(".txt"));
qd.ToList<string>().FindAll(p => p.EndsWith(".txt")).ForEach((file) =>
{
if (file != null && file.Length > 0)
{
//去掉文件名前的下划线以标识当前文件已经被更新
if (File.Exists(phyDirBase + "\\" + currEquid + "\\" + file))
{
File.Move(phyDirBase + "\\" + currEquid + "\\" + file, phyDirBase + "\\" + currEquid + "\\" + file.Substring(1));
}
filecontent = ExtractInfoFromText(phyDirBase + "\\" + currEquid + "\\" + file.Substring(1));
drQuality["LONGITUDE"] = filecontent["LNG"];
drQuality["LATITUDE"] = filecontent["LAT"];
drQuality["CREATED"] = drQuality["MODIFIED"] = Convert.ToDateTime(filecontent["TIME"]);
drQuality["ISVOID"] = "N";
drQuality["MPID"] = filecontent["MPID"];
drQuality["TYPE"] = filecontent["TYPE"];
}
//QualityData.Tables[0].Rows.Add(
});
//图片文件
qd.ToList<string>().FindAll(p => p.EndsWith(".jpg")).ForEach((file) =>
{
if (file != null && file.Length > 0)
{
//去掉文件名前的下划线以标识当前文件已经被更新
if (File.Exists(phyDirBase + "\\" + currEquid + "\\" + file))
{
File.Move(phyDirBase + "\\" + currEquid + "\\" + file, phyDirBase + "\\" + currEquid + "\\" + file.Substring(1));
}
if (drQuality["MATERIAL"].ToString().Length == 0)
{
drQuality["MATERIAL"] = phyDirBase + "\\" + currEquid + "\\" + file.Substring(1);
}
else
{
drQuality["MATERIAL"] = drQuality["MATERIAL"].ToString() + "|" + phyDirBase + "\\" + currEquid + "\\" + file.Substring(1);
}
}
});
//视频文件
qd.ToList<string>().FindAll(p => p.EndsWith(".mpg") || p.EndsWith(".3gp")).ForEach((file) =>
{
if (file != null && file.Length > 0)
{
//去掉文件名前的下划线以标识当前文件已经被更新
if (File.Exists(phyDirBase + "\\" + currEquid + "\\" + file))
{
File.Move(phyDirBase + "\\" + currEquid + "\\" + file, phyDirBase + "\\" + currEquid + "\\" + file.Substring(1));
}
drVideo["VIDEOID"] = srv.VideoService.GetNextSequenceID();
drVideo["CREATED"] = drVideo["MODIFIED"] = drQuality["CREATED"];
drVideo["VIDEONAME"] = drVideo["VIDEONAME"].ToString() + "|" + file.Substring(1);
drVideo["CREATEDBY"] = drVideo["MODIFIEDBY"] = drQuality["CREATEDBY"];
drVideo["VIDEOURL"] = drVideo["VIDEOURL"].ToString() + "|" + (phyDirBase + "\\" + currEquid + "\\" + file.Substring(1));
drVideo["ORGANIZATIONID"] = empinfo["OrganizationID"];
drVideo["TRACE"] = filecontent["TRACE"];
//处理监控点与视频的映射
drMonitorVideo["MPID"] = filecontent["MPID"];
drMonitorVideo["VIDEOID"] = drVideo["VIDEOID"];
}
});
#endregion
}
} while (files.Length > 0);
}
#region 批量保存
srv.Save(QualityData);
if (VideoData.Tables[0].Rows.Count > 0)
{
srv.VideoService.Save(VideoData);
srv.mvService.Save(mvData);
}
#endregion
}
private IDictionary<string, string> ExtractInfoFromText(string fileName)
{
IDictionary<string, string> item = new Dictionary<string, string>();
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
using (StreamReader reader = new StreamReader(fs))
{
string text = reader.ReadToEnd();
string[] infos = text.Split(new char[] { '#' });
if (infos.Length > 0)
{
item.Add("LNG", infos[0]);
item.Add("LAT", infos[1]);
item.Add("TIME", Convert.ToDateTime(infos[2]).ToString());
item.Add("MPID", infos[3]);
item.Add("TYPE", infos[4]);
item.Add("TRACE", infos[5]);
}
}
}
return item;
}
}
}
|
using UnityEngine;
using System.Collections;
public class Night_Vision : MonoBehaviour {
private Shader _shader;
private Shader shader
{
get { return _shader != null ? _shader : (_shader = Shader.Find("Hidden/Night_Vision")); }
}
private Material _material;
private Material material
{
get
{
if (_material == null)
{
_material = new Material(shader);
_material.hideFlags = HideFlags.HideAndDontSave;
}
return _material;
}
}
public float contrast = 2.0f;
public float brightness = 1.0f;
public float scanLineTiling = 4.0f;
public Vector2 noiseSpeed = new Vector2(100.0f, 100.0f);
public Color NV_Color = Color.white;
public Texture2D Vignette;
public Texture2D Scanline;
public Texture2D Noise;
private float randomValue = 0.0f;
void Update(){
contrast = Mathf.Clamp (contrast, 0.0f, 4.0f);
brightness = Mathf.Clamp (brightness, 0.0f, 2.0f);
randomValue = Random.Range (-1.0f, 1.0f);
}
void OnRenderImage(RenderTexture src, RenderTexture dest){
if (shader != null) {
material.SetFloat ("_Contrast", contrast);
material.SetFloat ("_Brightness", brightness);
material.SetFloat ("_RandomValue", randomValue);
material.SetColor ("_NightVisionColor", NV_Color);
if (Vignette)
material.SetTexture ("_VignetteTex", Vignette);
if (Scanline) {
material.SetTexture ("_ScanlineTex", Scanline);
material.SetFloat ("_ScanlineTiling", scanLineTiling);
}
if (Noise) {
material.SetTexture ("_NoiseTex", Noise);
material.SetVector ("_NoiseSpeed", noiseSpeed);
}
Graphics.Blit (src, dest, material);
} else {
Graphics.Blit (src, dest);
}
}
}
|
using StackExchange.Redis;
using System.Collections.Generic;
using Microsoft.UnifiedPlatform.Service.Common.Redis;
namespace Microsoft.UnifiedPlatform.Service.Redis
{
public class RedisConnectionManger: IRedisConnectionManager
{
public static Dictionary<string, IConnectionMultiplexer> Multiplexers = new Dictionary<string, IConnectionMultiplexer>();
public IConnectionMultiplexer CreateConnection(string connectionString)
{
if (Multiplexers.ContainsKey(connectionString))
{
var mux = Multiplexers[connectionString];
if (mux.IsConnected)
return mux;
mux = ConnectionMultiplexer.Connect(connectionString);
return mux;
}
var newMux = ConnectionMultiplexer.Connect(connectionString);
Multiplexers.Add(connectionString, newMux);
return newMux;
}
}
}
|
using System.Web.Mvc;
namespace AttendanceWebApp.Controllers
{
public class MedicalFitnessController : Controller
{
// GET: MedicalFittness
public ActionResult MedicalFit() => Session["EmpUnqId"] != null && Session["UserRole"] != null ? View() : (ActionResult)RedirectToAction("Index", "Login");
public ActionResult MedicalFitReport() => Session["EmpUnqId"] != null && Session["UserRole"] != null ? View() : (ActionResult)RedirectToAction("Index", "Login");
}
} |
using HowLeaky.CustomAttributes;
using HowLeaky.ModelControllers;
using HowLeaky.Tools;
using HowLeaky.Tools.DataObjects;
using HowLeaky.Models;
using System;
using HowLeaky.DataModels;
namespace HowLeaky.ModelControllers
{
public class NitrateController : HLObject
{
public NitrateDataModel data;
//**************************************************************************
//Outputs
//**************************************************************************
public OutputParameter out_N03NDissolvedInRunoff_mg_per_L { get; set; } // Dissolved N03 N In Runoff (mg/L)
public OutputParameter out_N03NRunoffLoad_kg_per_ha { get; set; } // N03 Runoff Load (kg/ha)
public OutputParameter out_N03NDissolvedLeaching_mg_per_L { get; set; } // Dissolved N03 N In Leaching (mg/L)
public OutputParameter out_N03NLeachingLoad_kg_per_ha { get; set; } // N03 N Leaching Load (kg/ha)
public OutputParameter out_ParticNInRunoff_kg_per_ha { get; set; } // Particulate N in Runoff (kg/ha)
public OutputParameter out_N03NStoreTopLayer_kg_per_ha { get; set; } // N03 N Store in top layer (kg/ha)
public OutputParameter out_N03NStoreBotLayer_kg_per_ha { get; set; } // N03 N Store in bot layer (kg/ha)
public OutputParameter out_TotalNStoreTopLayer_kg_per_ha { get; set; } // Total N Store in top layer (kg/ha)
public OutputParameter out_PNHLC_kg_per_ha { get; set; } // PNHLC (kg/ha)
public OutputParameter out_DrainageInN03Period_mm { get; set; } //
public OutputParameter out_RunoffInN03Period_mm { get; set; } //
//**************************************************************************
//Internals
//**************************************************************************
public int nitratesdayindex1 { get; set; }
public int nitratesdayindex2 { get; set; }
public int nitratesdayindex3 { get; set; }
//**************************************************************************
/// <summary>
///
/// </summary>
public NitrateController() { }
/// <summary>
///
/// </summary>
/// <param name="sim"></param>
public NitrateController(Simulation sim) : base(sim) { }
/// <summary>
///
/// </summary>
public override void Initialise()
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
public void InitialiseNitrateParameters()
{
nitratesdayindex1 = 0;
nitratesdayindex2 = 0;
nitratesdayindex3 = 0;
}
/// <summary>
///
/// </summary>
public override void Simulate()
{
try
{
bool _CanSimulateNitrate = (data.DissolvedNInRunoffInputOptions != 0 || data.DissolvedNInLeachingInputOptions != 0 || data.ParticulateNInRunoffInputOptions != 0);
if (_CanSimulateNitrate)
{
if (CanCalculateDissolvedNInRunoff()) CalculateDissolvedNInRunoff();
if (CanCalculateDissolvedNInLeaching()) CalculateDissolvedNInLeaching();
if (CanCalculateParticulateNInRunoff()) CalculateParticulateNInRunoff();
UpdateNitrateSummaryValues();
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
///
/// </summary>
public void UpdateNitrateSummaryValues() { }
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool CanCalculateDissolvedNInRunoff()
{
if (data.DissolvedNInRunoffInputOptions == 1)
return data.NLoadInSurfaceLayerTimeSeries.GetCount() != 0;
else if (data.DissolvedNInRunoffInputOptions == 2)
return true;
return false;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool CanCalculateDissolvedNInLeaching()
{
if (data.DissolvedNInLeachingInputOptions == 1)
return data.NLoadInLowerLayersTimeSeries.GetCount() != 0;
else if (data.DissolvedNInLeachingInputOptions == 2)
return true;
return false;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool CanCalculateParticulateNInRunoff()
{
if (data.ParticulateNInRunoffInputOptions == 1)
return data.SoilInorganicNitrateNTimeSeries.GetCount() != 0 &&
data.SoilInorganicAmmoniumNTimeSeries.GetCount() != 0 &&
data.SoilInorganicAmmoniumNTimeSeries.GetCount() != 0;
else if (data.ParticulateNInRunoffInputOptions == 2)
return true;
return false;
}
//From Howleaky developers (Brett Robinson), based on the concept that soil and runoff water mixing increases up to a maximum of k.
// DN = Nsurface * K(1- Math.Exp(-cvQ)
// where DN is the Nitrate conc in the runoff (mg/L)
// k is the parameter that regulates mixing of soil and runoff water, (suggested 0.5)
// cv is parameter that describes the curvature of change in the soil and water runoff at increasing runoff values (initial guess is 0.2)
// Q is runoff (mm)
// Nsurface (mg N/kg) is the soil nitrate concentrate in teh survace layer (0-2cm), which in our approach is derived from nitrate load (NLsoil in kg/ha) in surface layer from DairyMod
// NSurface = alpha*100*NLsoil/(depth*soildensity)
// Then dissolved N load (NL, kg/ha) in runoff is
// DL=ND*Q/100.0;
// NOTATION USE HERE IS TO BE CONSISTENT WITH THAT USED BY VIC DPI
/// <summary>
///
/// </summary>
public void CalculateDissolvedNInRunoff()
{
try
{
double NL_kg_ha = GetN03_N_Store_TopLayer_kg_per_ha(); //Nitrate load in surface layer (From Dairymod)
if (!MathTools.DoublesAreEqual(NL_kg_ha, MathTools.MISSING_DATA_VALUE))
{
NL_kg_ha = NL_kg_ha * data.SoilNLoadWeighting1;
double k = data.Nk; // INPUT parameter that regulates mixing of soil and runoff water
double cv = data.Ncv; //INPUT parameter that describes the curvature of change in soil and water runoff at increasing runoff values
double Q = sim.out_WatBal_Runoff_mm; //runoff amount
double d = data.NDepthTopLayer1_mm; //depth of surface soil layer mm
double phi = sim.in_BulkDensity_g_per_cm3[0]; //soil density t/m3 ( BulkDensity is in g/cm3)
double NSoil = data.NAlpha * 100.0 * NL_kg_ha / (d * phi); //mg/kg
double DN = NSoil * k * (1 - Math.Exp(-cv * Q));
double DL = DN * Q / 100.0;
out_N03NStoreTopLayer_kg_per_ha.SetValue(NL_kg_ha);
out_N03NDissolvedInRunoff_mg_per_L.SetValue(DN);
out_N03NRunoffLoad_kg_per_ha.SetValue(DL);
}
else
{
out_N03NStoreTopLayer_kg_per_ha.SetMissing();
out_N03NDissolvedInRunoff_mg_per_L.SetMissing();
out_N03NRunoffLoad_kg_per_ha.SetMissing();
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
// The nitrate concentrate in soil water contributing to leaching (mg/l) is
// LN= NSoil/(totalsoilwater)
// where NSoil is the nigrate concentration in the soil (kg/ha) and
// totalsoilwater is the soil water between air dry water content and saturated water content (mm) of the soil profile or the layer.
// Nitrate concentration in soil can either be for the soil profile or for the deepest soil layer.
// Concentration for the soil profile can be obtained from Math.Experiments or Math.Expert knowledge and soil nitrate concentration in the deepest soil layer can be informed by other nitrogen biophysical models (eg. DairyMod).
// Nitrate leaching load LL (kg /ha) is then calcualted as
// LL = LN*LE*D/100.0
// Where LE is the leaching efficiency parameter portioning soil water nitrate concentration into various pathways (often taken as 0.5)
// D is the daily drainage
// NOTATION USE HERE IS TO BE CONSISTENT WITH THAT USED BY VIC DPI
/// <summary>
///
/// </summary>
public void CalculateDissolvedNInLeaching()
{
try
{
double Nsoil_kg_per_ha = GetN03_N_Store_BotLayer_kg_per_ha(); //nitrate concentrate in the soil (kg/ha)
if (!MathTools.DoublesAreEqual(Nsoil_kg_per_ha, MathTools.MISSING_DATA_VALUE))
{
Nsoil_kg_per_ha = Nsoil_kg_per_ha * data.SoilNiLoadWeighting2;
double deltadepth = data.NDepthBottomLayer_mm;
if (deltadepth > 0)
{
double soilwater = (sim.in_SoilLimitSaturation_pc[sim.in_LayerCount - 1] - sim.in_SoilLimitAirDry_pc[sim.in_LayerCount - 1]) / 100.0 * deltadepth;
double LE = data.NLeachingEfficiency_pc; //Leaching efficiency (INPUT)
double D = sim.out_WatBal_DeepDrainage_mm; //Drainage (mm)
double LN = Nsoil_kg_per_ha * 1000000.0 / (soilwater * 10000.0);
double LL = (LN / 1000000.0) * D * 10000.0 * LE;
out_N03NStoreBotLayer_kg_per_ha.SetValue(Nsoil_kg_per_ha);
out_N03NDissolvedLeaching_mg_per_L.SetValue(LN);
out_N03NLeachingLoad_kg_per_ha.SetValue(LL);
}
else
{
out_N03NStoreBotLayer_kg_per_ha.SetMissing();
out_N03NDissolvedLeaching_mg_per_L.SetMissing();
out_N03NLeachingLoad_kg_per_ha.SetMissing();
}
}
else
{
out_N03NStoreBotLayer_kg_per_ha.SetMissing();
out_N03NDissolvedLeaching_mg_per_L.SetMissing();
out_N03NLeachingLoad_kg_per_ha.SetMissing();
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
// Particulate N Losses in runoff are modelled in a similar way to particulate P
// PN = beta*E*SDR*TNsoil*NER
// where PN is the particulate N load (kg/ha)
// TNsoil is the total N concentrate of the soil (mg/kg) and is the sum of the organica and inorganic N concentrations at 0-2cm from DairyMod.
// As TNsoil will be derived from DairyMod in kg/ha, we need to convert this to mg.kg.
// E is the gross errosion (kg/ha)
// SDR is the sediment delivery ratio
// NER is the Nitrogen enrichment ratio, which is unitless and defined similary to PER (for P)
// Beta is a conversion factor to adjust units and that can be used as a calibration factor.
// NOTATION USE HERE IS TO BE CONSISTENT WITH THAT USED BY VIC DPI
/// <summary>
///
/// </summary>
public void CalculateParticulateNInRunoff()
{
try
{
double TNSoil_kg_per_ha = GetTotalN_Store_TopLayer_kg_per_ha(); // Total N Concentration in soil (mg/kg) and is sum of organanic and inorgance conc at 0-2cm (Obtained from Dairymod)
if (!MathTools.DoublesAreEqual(TNSoil_kg_per_ha, MathTools.MISSING_DATA_VALUE))
{
TNSoil_kg_per_ha = TNSoil_kg_per_ha * data.SoilNLoadWeighting3;
double E = sim.out_Soil_HillSlopeErosion_t_per_ha * 1000.0;// Gross erosion (kg/ha)
double SDR = sim.in_SedDelivRatio; // Sediment delivery ratio.
double NER = data.NEnrichmentRatio; // Nitrogen enrighment ratio
double d = data.NDepthTopLayer2_mm; // depth of surface soil layer mm
double phi = sim.in_BulkDensity_g_per_cm3[0]; // soil density t/m3 ( BulkDensity is in g/cm3)
double NSoil = data.NAlpha2 * 100.0 * TNSoil_kg_per_ha / (d * phi); // mg/kg
double PN = data.NBeta * E * SDR * NSoil * NER / 1000000.0;
out_ParticNInRunoff_kg_per_ha.SetValue(PN);
if (!MathTools.DoublesAreEqual(SDR, 0) && !MathTools.DoublesAreEqual(sim.usle_ls_factor, 0))
out_PNHLC_kg_per_ha.SetValue(PN / (SDR * sim.usle_ls_factor));
else
out_PNHLC_kg_per_ha.SetZero();
out_TotalNStoreTopLayer_kg_per_ha.SetValue(TNSoil_kg_per_ha);
}
else
{
out_ParticNInRunoff_kg_per_ha.SetMissing();
out_PNHLC_kg_per_ha.SetMissing();
out_TotalNStoreTopLayer_kg_per_ha.SetMissing();
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
// Called from CalculateDissolvedNInRunoff
// extracts value directly from input time-series;
/// <summary>
///
/// </summary>
/// <returns></returns>
public double GetN03_N_Store_TopLayer_kg_per_ha()
{
try
{
if (data.DissolvedNInRunoffInputOptions == 1 && data.NLoadInSurfaceLayerTimeSeries.GetCount() != 0)
return data.NLoadInSurfaceLayerTimeSeries.GetValueAtDate(sim.today);
else if (data.DissolvedNInRunoffInputOptions == 2)
return data.SoilNLoadData1.GetValueForDayIndex("SoilNLoadData1", nitratesdayindex1, sim.today);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return 0;
}
// Called from CalculateDissolvedNInLeaching
// extracts value directly from input time-series OR can interpolate from user-defined values;
/// <summary>
///
/// </summary>
/// <returns></returns>
public double GetN03_N_Store_BotLayer_kg_per_ha()
{
try
{
if (data.DissolvedNInLeachingInputOptions == 1 && data.NLoadInLowerLayersTimeSeries.GetCount() != 0)
return data.NLoadInLowerLayersTimeSeries.GetValueAtDate(sim.today);
else if (data.DissolvedNInLeachingInputOptions == 2)
{
return data.SoilNLoadData2.GetValueForDayIndex("SoilNLoadData2", nitratesdayindex2, sim.today);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return 0;
}
// Called from CalculateParticulateNInRunoff
// extracts value directly from input time-series;
/// <summary>
///
/// </summary>
/// <returns></returns>
public double GetTotalN_Store_TopLayer_kg_per_ha()
{
try
{
if (data.ParticulateNInRunoffInputOptions == 1)
{
double value1 = 0;
double value2 = 0;
double value3 = 0;
if (data.SoilInorganicNitrateNTimeSeries.GetCount() != 0)
value1 = data.SoilInorganicNitrateNTimeSeries.GetValueAtDate(sim.today);
if (data.SoilInorganicAmmoniumNTimeSeries.GetCount() != 0)
value2 = data.SoilInorganicAmmoniumNTimeSeries.GetValueAtDate(sim.today);
if (data.SoilOrganicNTimeSeries.GetCount() != 0)
value3 = data.SoilOrganicNTimeSeries.GetValueAtDate(sim.today);
if (MathTools.DoublesAreEqual(value1, MathTools.MISSING_DATA_VALUE) || MathTools.DoublesAreEqual(value2, MathTools.MISSING_DATA_VALUE) || MathTools.DoublesAreEqual(value3, MathTools.MISSING_DATA_VALUE))
return MathTools.MISSING_DATA_VALUE;
return value1 + value1 + value3;
}
else if (data.ParticulateNInRunoffInputOptions == 2)
return data.SoilNLoadData3.GetValueForDayIndex("SoilNLoadData3", nitratesdayindex3, sim.today);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return 0;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool CanSimulateNitrate()
{
return (data.DissolvedNInRunoffInputOptions != 0 || data.DissolvedNInLeachingInputOptions != 0 || data.ParticulateNInRunoffInputOptions != 0);
}
}
}
|
namespace Sentry.Serilog;
internal static class SentryExtensions
{
public static bool TryGetSourceContext(this LogEvent logEvent, [NotNullWhen(true)] out string? sourceContext)
{
if (logEvent.Properties.TryGetValue("SourceContext", out var prop) &&
prop is ScalarValue {Value: string sourceContextValue})
{
sourceContext = sourceContextValue;
return true;
}
sourceContext = null;
return false;
}
public static SentryLevel? ToSentryLevel(this LogEventLevel loggingLevel)
{
return loggingLevel switch
{
LogEventLevel.Fatal => SentryLevel.Fatal,
LogEventLevel.Error => SentryLevel.Error,
LogEventLevel.Warning => SentryLevel.Warning,
LogEventLevel.Information => SentryLevel.Info,
LogEventLevel.Debug => SentryLevel.Debug,
LogEventLevel.Verbose => SentryLevel.Debug,
_ => null
};
}
public static BreadcrumbLevel ToBreadcrumbLevel(this LogEventLevel level)
{
return level switch
{
LogEventLevel.Verbose => BreadcrumbLevel.Debug,
LogEventLevel.Debug => BreadcrumbLevel.Debug,
LogEventLevel.Information => BreadcrumbLevel.Info,
LogEventLevel.Warning => BreadcrumbLevel.Warning,
LogEventLevel.Error => BreadcrumbLevel.Error,
LogEventLevel.Fatal => BreadcrumbLevel.Critical,
_ => (BreadcrumbLevel)level
};
}
}
|
using System;
namespace consoleproject
{
public class Messages
{
public Messages()
{
}
Random random = new Random();
public void openingMessages(Player player)
{
Console.WriteLine("Hello there " + player.Name + ". Glad to see a " + player.PlayerClass + " has joined the fight!");
Console.WriteLine("Attack : {0}", player.Attack);
Console.WriteLine("Defense : {0}", player.Defense);
Console.WriteLine("Health : {0}", player.Health);
}
public void fightFailure(Player player)
{
Console.WriteLine("It appears as though " + player.Name + " has fallen");
}
/**
* When a player wins a fight we reward them with XP
*/
public int fightSuccess(Player player, Enemy enemy)
{
int num = random.Next(10);
Console.WriteLine(player.Name + " has killed " + enemy.Name);
return num;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Text;
namespace Hayaa.Security.Service.Dao
{
internal partial class AppTokenDal
{
internal static AppToken Get(int appId,String token)
{
string sql = "select * from AppToken where Status=1 and AppId=@AppId and Token=@Token";
return Get<AppToken>(con, sql, new { AppId = appId,Token=token });
}
internal static AppToken GetByAppId(int appId)
{
string sql = "select * from AppToken where AppId=@AppId";
return Get<AppToken>(con, sql, new { AppId = appId});
}
}
}
|
using TAiMStore.Domain;
using TAiMStore.Model.Factory;
namespace TAiMStore.Model.Repository
{
public class OrderRepository : RepositoryBase<Order>, IOrderRepository
{
public OrderRepository(IFactory databaseFactory)
: base(databaseFactory)
{
}
}
}
|
using AboHassansFart.ProgramLogic;
using System;
namespace AboHassansFart
{
class Program
{
static void Main(string[] args)
{
BrowseStore store = new BrowseStore();
store.Run();
}
}
}
|
using System;
using System.Windows.Input;
using VideoStream.ViewModels;
namespace VideoStream.Commands
{
public class RefreshHistoryCommand :ICommand
{
private MainPageViewModel MainPageVM;
public RefreshHistoryCommand(MainPageViewModel mainPageVM)
{
MainPageVM = mainPageVM;
}
public event EventHandler CanExecuteChanged;
public bool CanExecute(object parameter)
{
return true;
}
public async void Execute(object parameter)
{
MainPageVM.IsRefreshing = true;
MainPageVM.History = await App.Database.GetAllVideos();
MainPageVM.IsRefreshing = false;
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
namespace Euler_Logic.Problems.AdventOfCode.Y2020 {
public class Problem13 : AdventOfCodeBase {
public override string ProblemName => "Advent of Code 2020: 13";
public override string GetAnswer() {
return Answer2(Input()).ToString();
}
public ulong Answer1(List<string> input) {
var notes = GetNotes(input);
ulong lowest = ulong.MaxValue;
ulong result = 0;
foreach (var num in notes.Buses) {
if (num != 0) {
var mod = notes.Num % num;
var remaining = num - mod;
if (remaining < lowest) {
lowest = remaining;
result = remaining * num;
}
}
}
return result;
}
public ulong Answer2(List<string> input) {
var notes = GetNotes(input);
ulong offset = notes.Buses[0];
ulong start = notes.Buses[0];
ulong last = notes.Buses[0];
for (int index = 1; index < notes.Buses.Count; index++) {
if (notes.Buses[index] != 0) {
var bus = notes.Buses[index];
ulong indexOffset = 0;
if (bus > (ulong)index) {
indexOffset = bus - (ulong)index;
} else {
indexOffset = bus - ((ulong)index % bus);
}
ulong nextOffset = start;
ulong mod = 0;
do {
mod = nextOffset % bus;
if (mod == indexOffset) {
break;
}
nextOffset += offset;
} while (true);
offset *= bus;
start = nextOffset;
last = notes.Buses[index];
}
}
return start;
}
private Notes GetNotes(List<string> input) {
var notes = new Notes();
notes.Num = Convert.ToUInt64(input[0]);
var split = input[1].Split(',');
notes.Buses = split.Select(id => {
if (id == "x") {
return Convert.ToUInt64(0);
} else {
return Convert.ToUInt64(id);
}
}).ToList();
return notes;
}
private List<string> TestInput() {
return new List<string>() {
"1008713",
"7,13,x,x,59,x,31,19"
};
}
private class Notes {
public ulong Num { get; set; }
public List<ulong> Buses { get; set; }
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.WebPages;
namespace StackExchange.Profiling
{
/// <summary>
/// Used to provide
/// </summary>
public static class ClientTimingHelper
{
/// <summary>
/// This code needs to be inserted in the page before client timings work
/// </summary>
public const string InitScript = "<script type='text/javascript'>mPt=function(){var t=[];return{results:function(){return t},probe:function(n){t.push({d:new Date(),n:n})},flush:function(){t=[]}}}()</script>";
/// <summary>
/// You can wrap an html block with timing wrappers using this helper
/// </summary>
public static string TimeScript(string name, string html)
{
if (MiniProfiler.Current != null)
{
name = name.Replace("'", "\\'");
var probe = "<script type='text/javascript'>mPt.probe('" + name + "')</script>";
html = probe + html + probe;
}
return html;
}
/// <summary>
/// This needs to be called at the begining of the layout for client side probe support, returns nothing if mini profiler is not enabled
/// </summary>
public static IHtmlString InitClientTimings(this WebPageBase page)
{
if (MiniProfiler.Current == null) return null;
return new HtmlString(InitScript);
}
/// <summary>
/// To be used inline in razor pages - times a script be sure to call InitClientTimings first
/// </summary>
public static IHtmlString TimeScript(this WebPageBase page, string name, Func<object, HelperResult> html)
{
var result = html(null).ToHtmlString();
return new HtmlString(TimeScript(name, result));
}
/// <summary>
/// To be used inline in razor pages - times a script be sure to call InitClientTimings first
/// </summary>
public static IHtmlString TimeScript(this WebPageBase page, string name, IHtmlString html)
{
return new HtmlString(TimeScript(name, html.ToHtmlString()));
}
/// <summary>
/// To be used inline in razor pages - times a script be sure to call InitClientTimings first
/// </summary>
public static IHtmlString TimeScript(this WebPageBase page, string name, string html)
{
return new HtmlString(TimeScript(name, html));
}
}
}
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
namespace CourseWork
{
public partial class FormD : Form
{
int index = 0;
MyAVL tree = new MyAVL();
List<ProcessedReq> ProcList = new List<ProcessedReq>();
HashTable tab = new HashTable();
List<Worker> list = new List<Worker>();
public FormD()
{
InitializeComponent();
Form MainForm = new MainForm();
MainForm.Hide();
tab.Clear();
string path = @"C:\Users\WhiteZetsu\source\repos\CourseWork\Workers.txt";
var flag = true;
try
{
StreamReader input = new StreamReader(path);
var ch = true;
dataGridView1.Rows.Clear();
while (!input.EndOfStream)
{
string s = input.ReadLine();
string[] subs = s.Split(' ');
Worker vova = new Worker(subs[0].Replace("_", " "), subs[1].Replace("_", " "));
list.Add(vova);
tab.Add(vova);
dataGridView1.Rows.Add(tab.Hash(vova.fio), vova.fio, vova.rodd);
}
MessageBox.Show("Файл успешно считан!");
}
catch (Exception)
{
MessageBox.Show("Ошибка входных данных!");
}
string path1 = @"C:\Users\WhiteZetsu\source\repos\CourseWork\ProcRequests.txt";
StreamReader input1 = new StreamReader(path1);
try
{
var ch1 = true;
dataGridView2.Rows.Clear();
while (!input1.EndOfStream)
{
string s1 = input1.ReadLine();
string[] subs1 = s1.Split(' ');
string[] dates1 = subs1[0].Split('.');
if (!subs1[0].Contains('.'))
{
ch1 = false;
}
if (subs1[subs1.Length - 1].ToCharArray()[0] != '8' || subs1[subs1.Length - 1].ToCharArray().Length != 11)
{
ch1 = false;
}
var problem1 = subs1[1].ToCharArray();
var worker = subs1[3].ToCharArray();
var customer = subs1[2].ToCharArray();
if (problem1.Length > 30)
{
ch1 = false;
}
for (var i = 0; i < problem1.Length; i++)
{
if ((problem1[i] < 'А'))
{
if ((problem1[i] != '!') && (problem1[i] != ',') && (problem1[i] != '.') && (problem1[i] == ' ') && (problem1[i] != '_'))
{
ch1 = false;
}
}
}
if (dates1.Length != 3)
ch1 = false;
if (int.Parse(dates1[0]) < 1 || int.Parse(dates1[0]) > 31 || int.Parse(dates1[1]) < 0 || int.Parse(dates1[1]) > 12 || int.Parse(dates1[2]) < 2007 || int.Parse(dates1[2]) > 2030)
{
ch1 = false;
}
for (var i = 0; i < worker.Length; i++)
{
if ((worker[i] < 'А'))
{
if ((worker[i] != '!') && (worker[i] != ',') && (worker[i] != '.') && (worker[i] == ' ') && (worker[i] != '_'))
{
ch1 = false;
}
}
}
for (var i = 0; i < customer.Length; i++)
{
if ((customer[i] < 'А'))
{
if ((customer[i] != '!') && (customer[i] != ',') && (customer[i] != '.') && (customer[i] == ' ') && (customer[i] != '_'))
{
ch1 = false;
}
}
}
if (ch1 != false)
{
ProcessedReq r = new ProcessedReq(new DateKey(int.Parse(dates1[0]), int.Parse(dates1[1]), int.Parse(dates1[2])), subs1[subs1.Length - 1], subs1[3].Replace('_', ' '), subs1[2].Replace('_', ' '), subs1[1].Replace('_', ' '));
ProcList.Add(r);
tree.Add(r.worker, index);
index++;
}
else
{
flag = false;
break;
}
}
if (flag != false)
MessageBox.Show("Файл успешно считан!");
else
{
MessageBox.Show("Ошибка входных данных!");
Application.Exit();
}
}
catch (Exception)
{
MessageBox.Show("Ошибка входных данных!");
Application.Exit();
}
finally
{
input1.Close();
}
foreach (var it in ProcList)
{
dataGridView2.Rows.Add(it.Key.dd.ToString() + "." + it.Key.mm.ToString() + "." + it.Key.yy.ToString(), it.problem, it.customer, it.worker, it.num);
}
}
private void RefreshDataGrid()
{
dataGridView1.Rows.Clear();
foreach (var it in list)
{
dataGridView1.Rows.Add(tab.Hash(it.fio), it.fio, it.rodd);
}
}
private void RefreshDataGrid1()
{
dataGridView2.Rows.Clear();
foreach (var it in ProcList)
{
dataGridView2.Rows.Add(it.Key.dd.ToString() + "." + it.Key.mm.ToString() + "." + it.Key.yy.ToString(), it.problem, it.customer, it.worker, it.num);
}
}
private void button1_Click(object sender, EventArgs e)
{
addWork addForm = new addWork();
DialogResult dr = addForm.ShowDialog();
if (dr == DialogResult.OK)
{
Worker vova = addForm.newWorker();
if (tab.Find(vova.fio) == null)
{
tab.Add(vova);
list.Add(vova);
RefreshDataGrid();
MessageBox.Show("Работник успешно добавлен!");
}
else MessageBox.Show("Такой работник уже есть.");
}
}
private void button2_Click(object sender, EventArgs e)
{
delWork addForm = new delWork();
DialogResult dr = addForm.ShowDialog();
if (dr == DialogResult.OK)
{
string fio = "";
string rodd = "";
addForm.GetKey(ref fio, ref rodd);
try
{
if (tab.Find(fio) != null)
{
var vova = new Worker(fio, rodd);
tab.Del(vova);
list.Remove(vova);
RefreshDataGrid();
MessageBox.Show("Работник успешно удален!");
}
else
{
MessageBox.Show("Такого работника не существует!");
}
}
catch (Exception)
{
MessageBox.Show("Ошибка ввода!");
}
}
}
private void button3_Click(object sender, EventArgs e)
{
searchWork addForm = new searchWork();
DialogResult dr = addForm.ShowDialog();
if (dr == DialogResult.OK)
{
string fio = "";
string rodd = "";
addForm.GetKey1(ref fio, ref rodd);
try
{
var srch = tab.Find(fio);
if (srch != null)
{
dataGridView1.Rows.Clear();
dataGridView1.Rows.Add(tab.Hash(fio), fio, rodd);
}
else MessageBox.Show("Такого работника не существует!");
}
catch (Exception)
{
MessageBox.Show("Такого работника не существует!");
}
}
}
private void button4_Click(object sender, EventArgs e)
{
RefreshDataGrid();
}
private void button10_Click(object sender, EventArgs e)
{
}
private void button8_Click(object sender, EventArgs e)
{
Form6 addForm = new Form6();
DialogResult dialogResult = addForm.ShowDialog();
if (dialogResult == DialogResult.OK)
{
ProcessedReq N = addForm.NewProcRequest();
bool foundin = false;
if (tab.Find(N.worker) != null)
{
if (tree.Find(N.worker, tree.root) == null)
{
tree.Add
}
else
{
MessageBox.Show("Заявка уже обработана!");
}
}
else MessageBox.Show("Невозможно обработать несуществующую заявку!");
}
}
}
}
|
using Compent.Shared.DependencyInjection.Contract;
using Uintra.Core.Activity;
using Uintra.Core.Feed.Services;
using Uintra.Features.Events;
using Uintra.Features.Events.Entities;
using Uintra.Features.Notification.Services;
using Uintra.Features.Subscribe;
namespace Uintra.Infrastructure.Ioc
{
public class EventInjectModule : IInjectModule
{
public IDependencyCollection Register(IDependencyCollection services)
{
services.AddScoped<IEventsService<Event>, EventsService>();
services.AddScopedToCollection<IFeedItemService, EventsService>();
services.AddScopedToCollection<INotifyableService, EventsService>();
services.AddScoped<ICacheableIntranetActivityService<Event>, EventsService>();
services.AddScoped<IIntranetActivityService, EventsService>();
services.AddScoped<ISubscribableService, EventsService>();
return services;
}
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Task2
{
class Program
{
static void Main(string[] args)
{
Console.CursorVisible = false;
Console.WriteLine("Введите число");
string str = Console.ReadLine();
string ok = str.Rez();
Console.WriteLine(ok);
Console.ReadKey();
}
}
}
|
namespace Kremen
{
using System;
using System.Collections.Generic;
using System.Linq;
using Kremen.Factories;
using Kremen.Models;
class Program
{
static void Main(string[] args)
{
string input = Console.ReadLine();
List<HouseHold> kermen = new List<HouseHold>();
int couter = 0;
while (input != "Democracy")
{
couter++;
try
{
HouseHold entry = HouseHoldFactory.CreateHouseHold(input);
kermen.Add(entry);
}
catch (Exception)
{
}
if (couter % 3 == 0)
{
kermen.ForEach(x => x.GetIncome());
}
if (input == "EVN bill")
{
kermen.RemoveAll(x => !x.CanPayBill());
kermen.ForEach(x => x.PayBills());
// foreach (var houseHold in kermen)
// {
// if (houseHold.CanPayBill())
// {
// houseHold.PayBills();
// }
// }
}
else if (input == "EVN")
{
Console.WriteLine($"Total population: {kermen.Sum(x => x.Consumation)}");
}
input = Console.ReadLine();
}
Console.WriteLine($"Total population: {kermen.Sum(x => x.Population)}");
}
}
}
|
using System;
using System.IO;
using UnityEngine;
using GFW;
namespace CodeX
{
public class CheckPackageStateListner : IGameStateListner
{
private bool m_finish_state = false;
public override void OnStateEnter(GameState pCurState)
{
Debug.Log("CheckPackageStateListner@OnStateEnter()");
if (AppConst.UpdateMode)
{
//AppFacade.Instance.GetManager<ResourceManager>(ManagerName.Resource).ReadDownloadHistory();
}
m_finish_state = true;
}
public override void OnStateQuit(GameState pCurState)
{
}
public override void OnStateUpdate(GameState pCurState, float elapseTime)
{
if (this.m_finish_state)
{
bool need_extract = GameConfig.Instance.IsPackChange();
if (need_extract)
{
CheckUpdateService.Instance.ToExtractResState();
}
else
{
if (AppConst.UpdateMode)
{
CheckUpdateService.Instance.ToUpdateVersionFileState();
}
else
{
CheckUpdateService.Instance.ToPreResState();
}
}
}
}
public override void Free()
{
}
}
}
|
using Avalonia;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Markup.Xaml;
namespace Toope_Varastonhallinta
{
public class App : Application
{
public static Tietokantakonteksti DB = new Tietokantakonteksti();
public override void Initialize()
{
AvaloniaXamlLoader.Load(this);
DB.Database.EnsureCreated();
}
public override void OnFrameworkInitializationCompleted()
{
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
{
desktop.MainWindow = new MainWindow();
}
base.OnFrameworkInitializationCompleted();
}
}
}
|
using System;
using System.Collections.Generic;
using System.Windows.Forms;
namespace Management_Plus
{
public class JGriedView : DataGridView
{
protected override bool ProcessDialogKey(Keys keyData)
{
if (keyData == Keys.Enter)
{
DataGridViewCell cc = CurrentCell;
EndEdit();
CurrentCell = null;
CurrentCell = cc;
base.ProcessTabKey(Keys.Tab);
return true;
}
return base.ProcessDialogKey(keyData);
}
protected override bool ProcessDataGridViewKey(KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
base.ProcessTabKey(Keys.Tab);
return true;
}
return base.ProcessDataGridViewKey(e);
}
private void InitializeComponent()
{
((System.ComponentModel.ISupportInitialize)(this)).BeginInit();
this.SuspendLayout();
((System.ComponentModel.ISupportInitialize)(this)).EndInit();
this.ResumeLayout(false);
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace KPIDemo.Entity
{
public class Student : BaseEntity
{
public string Name { get; set; }
public DateTime DateOfBirth { get; set; }
public string Address { get; set; }
public string PhoneNumber { get; set; }
public List<CourseResult> CourseResults { get; set; }
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Welic.Dominio.Models.Marketplaces.Entityes;
using Welic.Dominio.Models.Uploads.Maps;
using Welic.Dominio.Patterns.Service.Pattern;
namespace Welic.Dominio.Models.Uploads.Services
{
public interface IUploadsService : IService<UploadsMap>
{
//bool SavePath(string path);
}
}
|
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;
public class NavLevel1 : MonoBehaviour
{
public void BackToLevel0 ()
{
SceneManager.LoadScene("0_Home");
}
public void BackToLevel2()
{
SceneManager.LoadScene("2_Video");
}
}
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Sender : MonoBehaviour {
public delegate float PlayerDied(Vector3 player, Vector3 target);
public static event PlayerDied playerDiedInfo;
private bool isAlive;
void Start(){
Invoke("ExecuteEvent",3f);
}
void ExecuteEvent(){
// useful to prevent nullref in the case no object is subscribed to this event
if(playerDiedInfo != null){
playerDiedInfo(new Vector3(1f,1f,1f), new Vector3(2f,2f,2f));
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Examen_Juan_Roncagliolo
{
public class Jugadores : Persona
{
public int Puntos_de_ataque;
public int Puntos_de_defensa;
public bool Es_arquero;
public int Numero_de_camiseta;
public bool Lesion;
public Jugadores(string nombre, int edad, string nacion, int sueldo, int puntos_de_ataque, int puntos_de_defensa, bool es_arquero, int numero_de_camiseta)
{
Nombre = nombre;
Edad = edad;
Nacion = nacion;
Sueldo = sueldo;
Puntos_de_ataque = puntos_de_ataque;
Puntos_de_defensa = puntos_de_defensa;
Es_arquero = es_arquero;
Numero_de_camiseta = numero_de_camiseta;
}
public void Avisar_lesion(Equipo equipo, Medico medico,Entrenador entrenador,double factor,int jugador)
{
if (Lesion ==true)
{
medico.Evaluar(equipo,factor, entrenador,jugador);
}
}
public string Infomacion()
{
string a = Nombre + " |" + Edad + " |" + Nacion + " |" + Sueldo + " |" + Puntos_de_ataque + " |" + Puntos_de_ataque + " |";
if (Es_arquero)
{
a+="Arquero";
}
a+= " |" +Numero_de_camiseta+"\n";
return a;
}
}
}
|
using System.Collections.Generic;
using Apache.Shiro.Authc;
using Apache.Shiro.Management;
using Apache.Shiro.Session;
namespace Apache.Shiro.Subject
{
public interface ISubjectContext : IDictionary<string, object>
{
bool Authenticated
{
get;
set;
}
IAuthenticationInfo AuthenticationInfo
{
get;
set;
}
IAuthenticationToken AuthenticationToken
{
get;
set;
}
string Host
{
get;
set;
}
IPrincipalCollection Principals
{
get;
set;
}
ISecurityManager SecurityManager
{
get;
set;
}
ISession Session
{
get;
set;
}
object SessionId
{
get;
set;
}
ISubject Subject
{
get;
set;
}
bool ResolveAuthenticated();
string ResolveHost();
IPrincipalCollection ResolvePrincipals();
ISecurityManager ResolveSecurityManager();
ISession ResolveSession();
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Framework.Core.Common;
using OpenQA.Selenium;
using OpenQA.Selenium.Support.PageObjects;
namespace Tests.Pages.Van.SocialOrg
{
public class SocialOrgNav
{
protected Driver _driver;
public SocialOrgNav(Driver driver)
{
_driver = driver;
}
public IWebElement SetUpCampaign { get { return _driver.FindElement(By.CssSelector("li.setup-campaign")); } }
public IWebElement Tasks { get { return _driver.FindElement(By.CssSelector("li.manage-tasks")); } }
public IWebElement Badges { get { return _driver.FindElement(By.CssSelector("li.manage-badges")); } }
public IWebElement Stats { get { return _driver.FindElement(By.CssSelector("li.manage-stats")); } }
public void ClickSetUpCampain()
{
SetUpCampaign.FindElement(By.CssSelector("a[href]")).Click();
}
public void ClickTasks()
{
Tasks.FindElement(By.CssSelector("a[href]")).Click();
}
public void ClickBadges()
{
Badges.FindElement(By.CssSelector("a[href]")).Click();
}
public void ClickStats()
{
Stats.FindElement(By.CssSelector("a[href]")).Click();
}
public void ClickNewCampain()
{
_driver.JavascriptClick(
_driver.FindElement(By.TagName("header")).
FindElement(By.CssSelector("a[href='/Campaign/CreateCampaignWithoutId']"))
);
}
public void GoToCampain(string campaign)
{
_driver.JavascriptClick(
_driver.FindElement(By.TagName("header"))
.FindElement(By.ClassName("campaignList"))
.FindElement(By.XPath(String.Format("//a[text()= '{0}']", campaign)))
);
}
public void GoToClientList()
{
_driver.GoToPage("http://stage.taskmaster.internal/Account/SelectClient");
}
}
}
|
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Entities.DataTransferObjects
{
public class ReportEntryDto
{
public int ID { get; set; }
public DateTime CreateDate { get; set; }
public DateTime LastMod { get; set; }
public DateTime ReportDate { get; set; }
public int RunsheetID { get; set; }
public RunsheetDto Runsheet { get; set; }
public int Col { get; set; }
public ICollection<ReportDataEntryDto> ReportDataEntries { get; set; }
}
public class ReportEntryForCreationDto
{
public DateTime CreateDate { get; set; }
public DateTime LastMod { get; set; }
[Required(ErrorMessage = "Report Date is Required.")]
public DateTime ReportDate { get; set; }
[Required(ErrorMessage = "A Runsheet Is Required")]
[Range(1, int.MaxValue,ErrorMessage ="The Runsheet ID Must be Greater than 0")]
public int RunsheetID { get; set; }
[Required(ErrorMessage = "A Column Is Required")]
[Range(1, int.MaxValue, ErrorMessage = "The Column must be greater than 0")]
public int Col { get; set; }
}
public class ReportEntryForUpdateDto
{
public DateTime CreateDate { get; set; }
public DateTime LastMod { get; set; }
[Required(ErrorMessage = "Report Date is Required.")]
public DateTime ReportDate { get; set; }
[Required(ErrorMessage = "A Runsheet Is Required")]
[Range(1, int.MaxValue, ErrorMessage = "The Runsheet ID Must be Greater than 0")]
public int RunsheetID { get; set; }
[Required(ErrorMessage = "A Column Is Required")]
[Range(1, int.MaxValue, ErrorMessage = "The Column must be greater than 0")]
public int Col { get; set; }
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using Properties.Core.Extensions;
using Properties.Core.Objects;
// ReSharper disable InconsistentNaming
namespace Properties.Infrastructure.Rightmove.Objects
{
public class RmrtdfPropertyDetails
{
private const int _summary_max_length = 1000;
private const int _description_max_length = 32000;
private const int _features_max_length = 10;
private readonly string _summary;
public string summary => _summary.Substring(0, Math.Min(_summary_max_length, _summary.Length));
private readonly string _description;
public string description => _description.Substring(0, Math.Min(_description_max_length, _description.Length));
private readonly IEnumerable<string> _features;
public IEnumerable<string> features => _features.Take(Math.Min(_features_max_length, _features.Count()));
public int bedrooms { get; }
public int bathrooms { get; }
public int furnished_type { get; }
public bool? pets_allowed { get; }
public static bool smokers_considered = false;
public RmrtdfPropertyDetails(Property property)
{
_summary = property.DealType == DealType.Free
? property.ShortDescription.Trim()
: $"NO FEES, NO DEPOSIT, NO UPFRONT RENT -{property.ShortDescription.Trim()}";
_description = AugmentLongDescription(property.PropertyDescription.Trim(), property.DealType);
bedrooms = int.Parse(property.PropertyDetails
.FirstOrDefault(p => p.DetailType == PropertyDetailType.NumberOfBedrooms)?
.DetailValue ?? "1");
bathrooms = int.Parse(property.PropertyDetails
.FirstOrDefault(p => p.DetailType == PropertyDetailType.NumberOfBathrooms)?
.DetailValue ?? "1");
furnished_type =
property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.Furnished)?
.DetailValue.ToUpper() == "TRUE"
? 0
: 2;
pets_allowed =
property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.PetFriendly)?
.DetailValue.ToUpper() == "TRUE";
_features = GenerateFeatures(property);
}
private static string AugmentLongDescription(string longdescription, DealType dealType)
{
if (dealType == DealType.Free)
return longdescription;
var a =
$"NO FEES, NO DEPOSIT, NO UPFRONT RENT\n\nMove in to this property for FREE \n\n{longdescription}\n\nBest of all you can move in for Free and pay your first month's rent 2 weeks later - simple as that!\n\nTo avoid missing out call us today or email us with your name and a phone number.";
var b =
$"*NO FEES, NO DEPOSIT, NO UPFRONT RENT*\n\n{longdescription}\n\nWith a normal agency/landlord this property could cost you over £2000 just to move in when you add up all the admin fees, deposit and upfront rent! \nLetMe charge you NOTHING!Available for viewings and ready to Let NOW!!";
return new Random().NextDouble() >= 0.5 ? a : b;
}
private IEnumerable<string> GenerateFeatures(Property property)
{
var list = new List<string>();
if (property.DealType != DealType.Free)
{
list.Add("Move in for free!");
list.Add("No deposit, No upfront rent & No fees to pay");
}
list.Add($"{bedrooms} Bed {property.PropertyType.GetDescription()}");
if (property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.Parking)?.DetailValue.ToUpper() == "TRUE")
{
list.Add("Parking available");
}
list.Add(
property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.PetFriendly)?
.DetailValue.ToUpper() == "TRUE"
? "Pets Welcome at this property"
: "Unfortunately this property doesn't accept pets");
if (property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.Furnished)?.DetailValue.ToUpper() == "TRUE")
{
list.Add("Furnished Property");
}
if (property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.Garden)?.DetailValue.ToUpper() == "TRUE")
{
list.Add("Outside Space/Garden");
}
if (property.PropertyDetails.FirstOrDefault(p => p.DetailType == PropertyDetailType.WhiteGoods)?.DetailValue.ToUpper() == "TRUE")
{
list.Add("White goods included");
}
return list;
}
}
}
|
namespace Server_CS
{
/// <summary>
/// Класс для хранения связки логин/пароль
/// </summary>
public class RegData
{
/// <summary>
/// Логин уникальный псевдоним пользователя
/// </summary>
public string Username { get; set; }
/// <summary>
/// Пароль - необходим для доступа
/// </summary>
public string Password { get; set; }
}
} |
namespace AkkaOverview.Providers.Factories
{
public enum StreamingProvider
{
OandaApi
}
} |
using UnityEngine;
using UnityEngine.AI;
[RequireComponent(typeof(Rigidbody))]
public class FollowPlayer : MonoBehaviour
{
GameObject player;
new Rigidbody rigidbody;
[SerializeField] float speed = 200;
[SerializeField] float distance = 10;
void Awake()
{
rigidbody = GetComponent<Rigidbody>();
}
void Start()
{
player = GameObject.FindGameObjectWithTag("Player");
}
void Update()
{
Follow();
}
void Follow()
{
if (player && Vector3.Distance(transform.position, player.transform.position) < distance)
{
var direction = player.transform.position - transform.position;
rigidbody.AddForce(direction.normalized * speed * Time.smoothDeltaTime * player.transform.localScale.x);
}
}
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DAL.Models
{
public class Client
{
public int Id { get; set; }
public string LegalId { get; set; }
public DateTime CreatedDate { get; set; }
public DateTime? DeactivationDate { get; set; }
public bool IsActive { get; set; }
public string Name { get; set; }
public string Address { get; set; }
public string ContactName { get; set; }
public string ContactPhone { get; set; }
public string ContactEmail { get; set; }
public string Notes { get; set; }
public int StoreId { get; set; }
public Store Store { get; set; }
public Client()
{
IsActive = true;
CreatedDate = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"));
}
public void Deactivate()
{
IsActive = false;
DeactivationDate = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"));
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.