sharepoint online – If we define a deny domain list inside the company wide setting, then can we define an allow list inside the site collection which overcome it?

I am reading this article inside Microsoft Docs:

Restrict sharing of SharePoint and OneDrive content by domain

and I know that if I define an Allow list inside the company wide settings then I can select from this list to define a more restrictive allow list inside the site collection.

But what happen if inside the company wide settings I define deny list, then can I overcome it by defining the denied domains from the company wide setting as allow domains inside the site collection?

web development – Python – MCQ- What advice would you give this company about the user interface for this application?

{ Python } (MCQ) A company uses an offline system order for selling products. The company wants to build a new online site. The data trends of current order shows that customers typically buy once or twice a year. The company has the following requirement for the site.

Should have ability to shop quickly from application
Should have ability for the web designers to modify the user interface to provide a new user experience
There should be ability to browse the catalog and find the product with 3 clicks
What advice would you give this company about the user interface for this application?

Options:

a> create UI by mixing HTML and Python codes by mixing libraries

b> not possible to build such UI requirement in python

c> write UI using Django Framework

d> write UI using Ajax accessing Python code

beginner – Company database REPL program in Rust for Chapter 8 of The Book

I implemented a solution for the third exercise of Chapter 8 of The Book. I’m still trying to build my intuition for what makes a good Rust program and so would really appreciate some pointers to help me improve. Here’s my current solution:

// Using a hash map and vectors, create a text interface to allow a user to
// add employee names to a department in a company. For example, “Add
// Sally to Engineering” or “Add Amir to Sales.” Then let the user retrieve
// a list of all people in a department or all people in the company by
// department, sorted alphabetically.

// @todo Add functions to remove people, departments and companies. Add a clear function.

use std::collections::HashMap;
use std::collections::HashSet;
use std::io;
use std::io::Write;

#(derive(Debug, PartialEq, Eq, Hash, Clone, PartialOrd, Ord))
struct Employee(String);
#(derive(Debug))
struct Department(HashSet<Employee>);
#(derive(Debug))
struct Company(HashMap<String, Department>);

fn make_company() -> Company {
    Company(HashMap::new())
}

#(derive(Debug))
struct ExistingDepartment(String);

// This assumes all department names are unique.
fn add_department(company: &mut Company, department: &str) -> Result<(), ExistingDepartment> {
    let department_name = String::from(department);
    match company.0.contains_key(&department_name) {
        true => Err(ExistingDepartment(department_name)),
        false => {
            company
                .0
                .insert(department_name, Department(HashSet::<Employee>::new()));
            Ok(())
        }
    }
}

#(derive(Debug))
enum AddEmployeeError {
    NonexistentDepartment(String),
    ExistingEmployee(Employee),
}

// This assumes that all employee names in a department are unique.
fn add_employee(
    company: &mut Company,
    department_name: &str,
    employee: Employee,
) -> Result<(), AddEmployeeError> {
    match company.0.get_mut(department_name) {
        None => Err(AddEmployeeError::NonexistentDepartment(String::from(
            department_name,
        ))),
        Some(department) => match department.0.insert(employee.clone()) {
            true => Ok(()),
            false => Err(AddEmployeeError::ExistingEmployee(employee)),
        },
    }
}

#(derive(Debug))
struct NonexistentDepartment(String);

fn get_employees_department(
    company: &Company,
    department_name: &str,
) -> Result<Vec<Employee>, NonexistentDepartment> {
    match company.0.get(department_name) {
        None => Err(NonexistentDepartment(String::from(department_name))),
        Some(department) => {
            let mut result: Vec<Employee> = department.0.iter().cloned().collect();
            result.sort_unstable();
            Ok(result)
        }
    }
}

fn get_employees_company(company: &Company) -> Vec<Employee> {
    let mut result = company
        .0
        .keys()
        .map(|department| get_employees_department(company, department).unwrap())
        .collect::<Vec<Vec<Employee>>>()
        .concat();
    result.sort_unstable();
    result
}

fn format_slice(slice: &(Employee)) -> Option<String> {
    match slice.len() {
        0 => None,
        _ => Some(
            slice
                .iter()
                .map(|employee| employee.0.to_string())
                .collect::<Vec<String>>()
                .join("n"),
        ),
    }
}

#(derive(PartialEq))
enum GetInput {
    Print,
    Read,
    Parse,
}

#(derive(PartialEq))
enum Mode {
    Greet,
    GetInput(GetInput),
    Quit,
}

struct State {
    mode: Mode,
    company: Company,
    input: String,
}

fn make_state() -> State {
    State {
        company: make_company(),
        mode: Mode::Greet,
        input: String::new(),
    }
}

fn print_flush(input: &str) -> Result<(), std::io::Error> {
    print!("{}", input);
    io::stdout().flush()
}

fn read_line(string: &mut String) -> Result<usize, std::io::Error> {
    string.clear();
    io::stdin().read_line(string)
}

// This assumes that department and employee names don't have whitespace.
fn process_input(state: &mut State) {
    let company = &mut state.company;
    match state.input.len() {
        0 => {
            state.mode = Mode::GetInput(GetInput::Print);
        }
        _ => {
            let tokens: Vec<&str> = state.input.split_whitespace().collect();
            match tokens.get(0) {
                None => {
                    state.mode = Mode::GetInput(GetInput::Print);
                }
                Some(token) => match *token {
                    "quit" => {
                        println!("Bye for now!");
                        state.mode = Mode::Quit;
                    }
                    command => {
                        match command {
                            "add-department" => match tokens(1..).len() {
                                0 => println!("Command "{}" requires at least 1 argument.", command),
                                _ => tokens(1..).iter().for_each(|element| match add_department(company, element) {
                                    Ok(_) => (),
                                    Err(error) => println!("Error: {:?}", error)
                                })
                            },
                            "add-employee" => match tokens(1..).len() {
                                0 ..= 1 => println!("Command "{}" requires at least 2 arguments.", command),
                                _ => match company.0.contains_key(tokens(1)) {
                                    true => tokens(2..).iter().for_each(|employee| match add_employee(company, tokens(1), Employee(employee.to_string())) {
                                        Ok(_) => (),
                                        Err(error) => println!("Error: {:?}", error)
                                    }),
                                    false => println!("Department "{}" doesn't exist.", tokens(1))
                                }
                            },
                            "get-employees" => match tokens(1..).len() {
                                0 => println!("Command "{}" requires at least 1 argument.", command),
                                _ => tokens(1..).iter().for_each(|department| match company.0.contains_key(*department) {
                                    true => match format_slice(&get_employees_department(company, department).unwrap()) {
                                        None => println!("Department "{}" has no employees.", department),
                                        Some(employees) => println!(
                                            "Employees in "{}":
{}", department, employees)
                                    },
                                    false => println!("Department "{}" doesn't exist.", department)
                                })
                            },
                            "get-employees-all" => match format_slice(&get_employees_company(company)) {
                                None => println!("Company has no employees."),
                                Some(employees) => println!(
                                    "Employees:
{}", employees)
                            },
                            "help" => println!(
                                "Commands:

add-department <department_name (department_name ...)>
  Add one or more departments to the company.

add-employee <department_name> <employee_name (employee_name ...)>
  Add one or more employees to a department.

get-employees <department_name (department_name ...)>
  Print a list of employees from one or more departments.

get-employees-all
  Print a list of all employees in the company.

help
  Print this message.

quit
  Quit."
                            ),
                            command => {
                                println!("Invalid command "{}".", command);
                            }
                        }
                        state.mode = Mode::GetInput(GetInput::Print);
                    }
                },
            }
        }
    }
}

fn state_machine(state: &mut State) {
    match &state.mode {
        Mode::Greet => {
            println!(
                "Database program.
Enter "help" for a list of commands."
            );
            state.mode = Mode::GetInput(GetInput::Print);
        }
        Mode::GetInput(get_input_step) => match get_input_step {
            GetInput::Print => {
                println!("Company: {:?}", state.company);
                match print_flush("> ") {
                    Ok(_) => {
                        state.mode = Mode::GetInput(GetInput::Read);
                    }
                    Err(error) => println!("Error {:?}", error),
                }
            }
            GetInput::Read => match read_line(&mut state.input) {
                Ok(_) => {
                    state.mode = Mode::GetInput(GetInput::Parse);
                }
                Err(error) => println!("Error: {:?}", error),
            },
            GetInput::Parse => process_input(state),
        },
        Mode::Quit => (),
    }
}

fn repl(function: fn(&mut State), state: &mut State) {
    while state.mode != Mode::Quit {
        function(state)
    }
}

fn main() {
    repl(state_machine, &mut make_state())
}

I previously tried to refactor the process_input function to try to decrease nesting by moving parts of it to different functions, but I ran across borrowing issues so I stopped trying. I also couldn’t figure out a nice way to implement it such that it accepts inputs that use the same format as the example (i.e., “Add Amir to Sales”), so I did it a little differently.

I’m also not sure if I’m using the Result type nicely and if the tuple structs and enum I made to pass to them are a good way to do error handling.

I also feel like some of the cloning I did is probably unecessary, but I’m not sure how I could refactor them away, so it would be nice to know if that is indeed the case and how I might refactor. In fact, I think it would be helpful to know how I might determine when it is appropriate to clone or when to borrow, as I think I’m a little iffy about that topic.

On a related note, how should I go about writing functions? Is it generally better to initially write functions such that they clone their arguments, then try to refactor the cloning away later on, or to try to borrow everything up front then try to fix any borrow-checker issues that crop up and only clone if I can’t fix them?

In any case, I’d really appreciate any constructive criticisms and advice.