401 lines
10 KiB
Dart
401 lines
10 KiB
Dart
enum MenuSort {
|
|
nameAsc,
|
|
nameDesc,
|
|
timestampAsc,
|
|
timestampDesc,
|
|
}
|
|
|
|
enum ViewOrder {
|
|
swipedFirst,
|
|
matchedFirst,
|
|
swipedOnly,
|
|
matchedOnly,
|
|
}
|
|
|
|
enum Gender {
|
|
none,
|
|
male,
|
|
female,
|
|
divers;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case Gender.none:
|
|
return 'unknown';
|
|
case Gender.male:
|
|
return 'male';
|
|
case Gender.female:
|
|
return 'female';
|
|
case Gender.divers:
|
|
return 'diverse';
|
|
}
|
|
}
|
|
}
|
|
|
|
enum SkillOption {
|
|
management,
|
|
data,
|
|
design,
|
|
engineering,
|
|
finance,
|
|
it,
|
|
legal,
|
|
marketing,
|
|
operations,
|
|
product,
|
|
software;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case SkillOption.management:
|
|
return 'Business Development';
|
|
case SkillOption.data:
|
|
return 'Data Analysis and Analytics';
|
|
case SkillOption.design:
|
|
return 'Design';
|
|
case SkillOption.engineering:
|
|
return 'Engineering';
|
|
case SkillOption.finance:
|
|
return 'Finance and Accounting';
|
|
case SkillOption.it:
|
|
return 'Information Technology';
|
|
case SkillOption.legal:
|
|
return 'Legal';
|
|
case SkillOption.marketing:
|
|
return 'Marketing and Sales';
|
|
case SkillOption.operations:
|
|
return 'Operations Management';
|
|
case SkillOption.product:
|
|
return 'Product Development';
|
|
case SkillOption.software:
|
|
return 'Software Development';
|
|
}
|
|
}
|
|
}
|
|
|
|
enum VisionOption {
|
|
marketLeader,
|
|
sustainableBusiness,
|
|
innovativeProduct,
|
|
exitStrategy;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case VisionOption.marketLeader:
|
|
return 'Become market leader';
|
|
case VisionOption.sustainableBusiness:
|
|
return 'Build a sustainable and ethical business';
|
|
case VisionOption.innovativeProduct:
|
|
return "Develop an innovative product that improves people's lives";
|
|
case VisionOption.exitStrategy:
|
|
return 'Pursue an exit strategy through sale or IPO';
|
|
}
|
|
}
|
|
}
|
|
|
|
enum AvailabilityOption {
|
|
lessThan10Hours,
|
|
tenTo20Hours,
|
|
twentyTo40Hours,
|
|
fullTime,
|
|
flexible;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case AvailabilityOption.lessThan10Hours:
|
|
return 'Less than 10 hours';
|
|
case AvailabilityOption.tenTo20Hours:
|
|
return 'Part-time (10 - 20 hours)';
|
|
case AvailabilityOption.twentyTo40Hours:
|
|
return 'Part-time (20 - 40 hours)';
|
|
case AvailabilityOption.fullTime:
|
|
return 'Full-time (40 hours or more)';
|
|
case AvailabilityOption.flexible:
|
|
return 'Flexible, full-time or part-time';
|
|
}
|
|
}
|
|
|
|
String get commitmentText {
|
|
switch (this) {
|
|
case AvailabilityOption.lessThan10Hours:
|
|
return 'secondary occupation with less than 10 hours per week';
|
|
case AvailabilityOption.tenTo20Hours:
|
|
return 'part-time with 10 to 20 hours per week';
|
|
case AvailabilityOption.twentyTo40Hours:
|
|
return 'part-time with 20 to 40 hours per week';
|
|
case AvailabilityOption.fullTime:
|
|
return 'full-time';
|
|
case AvailabilityOption.flexible:
|
|
return 'full-time or part-time';
|
|
}
|
|
}
|
|
|
|
/// @returns [AvailabilityOption.lessThan10Hours] in case [str] is null or empty
|
|
static AvailabilityOption fromString(String? str) {
|
|
if (str == null || str.isEmpty) {
|
|
return AvailabilityOption.lessThan10Hours; // return a default value
|
|
}
|
|
return AvailabilityOption.values.firstWhere(
|
|
(x) => x.toString() == str,
|
|
orElse: () =>
|
|
throw ArgumentError('Invalid AvailabilityOption enum value: $str'),
|
|
);
|
|
}
|
|
}
|
|
|
|
enum WorkValueOption {
|
|
transparency,
|
|
innovation,
|
|
teamwork,
|
|
workLifeBalance;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case WorkValueOption.transparency:
|
|
return 'Transparency and openness';
|
|
case WorkValueOption.innovation:
|
|
return 'Innovation and creativity';
|
|
case WorkValueOption.teamwork:
|
|
return 'Teamwork and collaboration';
|
|
case WorkValueOption.workLifeBalance:
|
|
return 'Work-life balance';
|
|
}
|
|
}
|
|
}
|
|
|
|
enum CultureOption {
|
|
performanceOriented,
|
|
supportive,
|
|
flexible,
|
|
traditional;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case CultureOption.performanceOriented:
|
|
return 'Performance-oriented and competitive';
|
|
case CultureOption.supportive:
|
|
return 'Supportive and collegial';
|
|
case CultureOption.flexible:
|
|
return 'Flexible and adaptable';
|
|
case CultureOption.traditional:
|
|
return 'Traditional and structured';
|
|
}
|
|
}
|
|
|
|
/// @returns [CultureOption.traditional] in case [str] is null or empty
|
|
static CultureOption fromString(String? str) {
|
|
if (str == null || str.isEmpty) {
|
|
return CultureOption.traditional; // return a default value
|
|
}
|
|
return CultureOption.values.firstWhere(
|
|
(x) => x.toString() == str,
|
|
orElse: () =>
|
|
throw ArgumentError('Invalid CultureOption enum value: $str'),
|
|
);
|
|
}
|
|
}
|
|
|
|
enum CommunicationPreference {
|
|
daily,
|
|
weekly,
|
|
adhoc,
|
|
formal;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case CommunicationPreference.daily:
|
|
return 'Frequent updates and daily meetings';
|
|
case CommunicationPreference.weekly:
|
|
return 'Weekly summaries and updates';
|
|
case CommunicationPreference.adhoc:
|
|
return 'Ad-hoc communication as needed';
|
|
case CommunicationPreference.formal:
|
|
return 'Formal reports and documentation';
|
|
}
|
|
}
|
|
|
|
/// @returns [CommunicationPreference.daily] in case [str] is null or empty
|
|
static CommunicationPreference fromString(String? str) {
|
|
if (str == null || str.isEmpty) {
|
|
return CommunicationPreference.daily; // return a default value
|
|
}
|
|
return CommunicationPreference.values.firstWhere(
|
|
(x) => x.toString() == str,
|
|
orElse: () => throw ArgumentError(
|
|
'Invalid CommunicationPreference enum value: $str'),
|
|
);
|
|
}
|
|
}
|
|
|
|
enum RiskTolerance {
|
|
riskAverse,
|
|
cautious,
|
|
balanced,
|
|
adaptive,
|
|
riskTaker;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case RiskTolerance.riskAverse:
|
|
return 'Prefer avoiding risks whenever possible';
|
|
case RiskTolerance.cautious:
|
|
return 'Exercising caution to minimize potential losses';
|
|
case RiskTolerance.balanced:
|
|
return 'Neutral, carefully weighing potential opportunities and hazards';
|
|
case RiskTolerance.adaptive:
|
|
return 'Flexibly responding to changing risk scenarios';
|
|
case RiskTolerance.riskTaker:
|
|
return 'Proactively taking risks to maximize rewards';
|
|
}
|
|
}
|
|
|
|
/// @returns [RiskTolerance.balanced] in case [str] is null or empty
|
|
static RiskTolerance fromString(String? str) {
|
|
if (str == null || str.isEmpty) {
|
|
return RiskTolerance.balanced; // return a default value != null
|
|
}
|
|
return RiskTolerance.values.firstWhere(
|
|
(x) => x.toString() == str,
|
|
orElse: () =>
|
|
throw ArgumentError('Invalid RiskTolerance enum value: $str'),
|
|
);
|
|
}
|
|
}
|
|
|
|
enum SectorOption {
|
|
agriculture,
|
|
ai,
|
|
ar,
|
|
automotive,
|
|
beauty,
|
|
bigdata,
|
|
blockchain,
|
|
cloud,
|
|
construction,
|
|
consulting,
|
|
crypto,
|
|
cybersecurity,
|
|
ecommerce,
|
|
education,
|
|
energy,
|
|
fashion,
|
|
finance,
|
|
food,
|
|
gaming,
|
|
hardware,
|
|
healthcare,
|
|
home,
|
|
industry,
|
|
insurance,
|
|
iot,
|
|
it,
|
|
legal,
|
|
ml,
|
|
marketing,
|
|
media,
|
|
mobility,
|
|
pharma,
|
|
retail,
|
|
robotics,
|
|
saas,
|
|
sports,
|
|
software,
|
|
telecommunication,
|
|
transport,
|
|
travel,
|
|
vr,
|
|
web,
|
|
other;
|
|
|
|
String get displayName {
|
|
switch (this) {
|
|
case SectorOption.agriculture:
|
|
return 'Agriculture';
|
|
case SectorOption.ai:
|
|
return 'Artificial Intelligence';
|
|
case SectorOption.ar:
|
|
return 'Augmented Reality';
|
|
case SectorOption.automotive:
|
|
return 'Automotive';
|
|
case SectorOption.beauty:
|
|
return 'Beauty and Personal Care';
|
|
case SectorOption.bigdata:
|
|
return 'Big Data';
|
|
case SectorOption.blockchain:
|
|
return 'Blockchain';
|
|
case SectorOption.cloud:
|
|
return 'Cloud Computing';
|
|
case SectorOption.construction:
|
|
return 'Construction and Real Estate';
|
|
case SectorOption.consulting:
|
|
return 'Consulting and Agency';
|
|
case SectorOption.crypto:
|
|
return 'Cryptocurrencies and Digital Assets';
|
|
case SectorOption.cybersecurity:
|
|
return 'Cybersecurity';
|
|
case SectorOption.ecommerce:
|
|
return 'E-Commerce';
|
|
case SectorOption.education:
|
|
return 'Education';
|
|
case SectorOption.energy:
|
|
return 'Energy and Environment';
|
|
case SectorOption.fashion:
|
|
return 'Fashion and Lifestyle';
|
|
case SectorOption.finance:
|
|
return 'Finance';
|
|
case SectorOption.food:
|
|
return 'Food and Beverage';
|
|
case SectorOption.gaming:
|
|
return 'Gaming';
|
|
case SectorOption.hardware:
|
|
return 'Hardware';
|
|
case SectorOption.healthcare:
|
|
return 'Healthcare';
|
|
case SectorOption.home:
|
|
return 'Home and Garden';
|
|
case SectorOption.industry:
|
|
return 'Industry';
|
|
case SectorOption.insurance:
|
|
return 'Insurance';
|
|
case SectorOption.iot:
|
|
return 'Internet of Things';
|
|
case SectorOption.it:
|
|
return 'IT';
|
|
case SectorOption.legal:
|
|
return 'Legal and Compliance';
|
|
case SectorOption.ml:
|
|
return 'Machine Learning';
|
|
case SectorOption.marketing:
|
|
return 'Marketing and Advertising';
|
|
case SectorOption.media:
|
|
return 'Media and Entertainment';
|
|
case SectorOption.mobility:
|
|
return 'Mobility';
|
|
case SectorOption.pharma:
|
|
return 'Pharma';
|
|
case SectorOption.retail:
|
|
return 'Retail';
|
|
case SectorOption.robotics:
|
|
return 'Robotics';
|
|
case SectorOption.saas:
|
|
return 'SaaS';
|
|
case SectorOption.sports:
|
|
return 'Sports and Fitness';
|
|
case SectorOption.software:
|
|
return 'Software';
|
|
case SectorOption.telecommunication:
|
|
return 'Telecommunications';
|
|
case SectorOption.transport:
|
|
return 'Transport and Logistics';
|
|
case SectorOption.travel:
|
|
return 'Travel';
|
|
case SectorOption.vr:
|
|
return 'Virtual Reality';
|
|
case SectorOption.web:
|
|
return 'Web';
|
|
case SectorOption.other:
|
|
return 'Other';
|
|
}
|
|
}
|
|
}
|